/*

* 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 <sysutil.h> 

#include "hnxmlmodelprovider.h"

#include "hnxmlmodelcache.h"	

#include "hnxmlsuitefilesreg.h"

#include "hnglobals.h"

#include "hnconvutils.h"

#include "menudebug.h"

#include "hnhelper.inl"

#include "hnmdmodel.h"

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

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

// 

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

//

void CHnXmlModelProvider::ConstructL()

	{

	iDomImpl.OpenL();

	User::LeaveIfError(iDomParser.Open(iDomImpl));

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

	iFileMan = CFileMan::NewL(iFs);

	iPath.CreateL(KMaxPath);

	User::LeaveIfError(iFs.PrivatePath(iPath));

	iPath.Insert(0, KDrive);

	iPath.Append(KEntriesSuffix);

	iCache = CHnXmlModelCache::NewL();

	CActiveScheduler::Add( this);

	}

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

// 

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

//

void CHnXmlModelProvider::DoCancel()

	{

	}

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

// 

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

//

void CHnXmlModelProvider::SynchronizationFinishedL()

	{

	ResetCache();

	THnMdCommonPointers &cmnPtr = *THnMdCommonPointers::Static();

	CHnMdModel* model = cmnPtr.iModel;

	if ( iSuiteFilesUpdated )

	    {

	    model->ReloadStackSuitesL( cmnPtr.iContainer );

	    }

	}

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

// 

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

//

void CHnXmlModelProvider::RunL()

	{

	if ( !iSuiteSetIterator )

		{

		CheckDrivesL();

	    iSuiteSetIterator = new ( ELeave ) THashSetIter<HBufC*>( iInstSuites );

	    iSuiteSetIterator->Reset();

	    iStatus = KRequestPending;

	    SetActive();

	    TRequestStatus* status = &iStatus;

	    User::RequestComplete( status, KErrNone );

		}

	else if ( iSuiteSetIterator->Next() )

		{

		TBool filesUpdated = CHnXmlSuiteFilesReg::SynchronizeL(

                iFs, **(iSuiteSetIterator->Current()) );

        iSuiteFilesUpdated = ( iSuiteFilesUpdated || filesUpdated ); 

	    iStatus = KRequestPending;

	    SetActive();

	    TRequestStatus* status = &iStatus;

	    User::RequestComplete( status, KErrNone );

		}

	else

		{

		delete iSuiteSetIterator;

		iSuiteSetIterator = NULL;

		SynchronizationFinishedL();

		}

	}

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

// 

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

//

EXPORT_C CHnXmlModelProvider* CHnXmlModelProvider::NewL()

	{

	CHnXmlModelProvider* self = CHnXmlModelProvider::NewLC();

	CleanupStack::Pop(self);

	return self;

	}

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

// 

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

//

EXPORT_C CHnXmlModelProvider* CHnXmlModelProvider::NewLC()

	{

	CHnXmlModelProvider* self = new (ELeave) CHnXmlModelProvider;

	CleanupStack::PushL(self);

	self->ConstructL();

	return self;

	}

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

// 

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

//

CHnXmlModelProvider::CHnXmlModelProvider() :

	CActive( EPriorityLow ),	

	iInstSuites(&HBuf16Hash, &HBuf16Ident),

	iEventMap(&HBuf16Hash, &HBuf16Ident), 

	iSuiteSetIterator( NULL )

	{

	}

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

// 

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

//

EXPORT_C CHnXmlModelProvider::~CHnXmlModelProvider()

	{

	Cancel(); 

	delete iSuiteSetIterator;

	delete iCache;

	iDomParser.Close();

	iDomImpl.Close();

	delete iFileMan;

	iFs.Close();

	iPath.Close();

	// clean up eventmap

	THashMapIter<HBufC*, TInt> iter(iEventMap);

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

		{

		delete *ptr;

		}

	iEventMap.Close();

	THashSetIter<HBufC*> iterSuites(iInstSuites);

	while ( iterSuites.Next())

		{

		delete *iterSuites.Current();

		}

	iInstSuites.Close();

	}

#ifdef _DEBUG

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

// 

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

//

void CHnXmlModelProvider::LogEventMapping(

		const RHashMap<HBufC*, TInt>& aEventMap)

	{

    DEBUG(("\t_MM_: CHnXmlModelProvider::LogEventMapping IN"));

    RFs fs;

    if ( !fs.Connect() )

        {

        RFile logFile;

        if ( !logFile.Replace( fs, KEventMapLogFile, EFileWrite ) )

            {

            // first line

            TBuf8<256> buf1;

            buf1.Append( _L8("EventName") );

            buf1.Append( _L8("\t") );

            buf1.Append( _L8("EventId") );

            buf1.Append( _L8("\n") );

            logFile.Write( 0, buf1 );                    

            THashMapIter<HBufC*, TInt> iter( aEventMap );

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

                {

                TInt *v = iter.CurrentValue();

                TBuf8<256> buf2;

                buf2.Append( (*ptr)->Des() );

                buf2.Append( _L8("\t") );

                buf2.AppendNum( *v );

                buf2.Append( _L8("\n") );

                TInt size ( 0 );

                logFile.Size( size );

                logFile.Write( size, buf2 );

                }

            logFile.Close();

            }

        fs.Close();

        }

    DEBUG(("\t_MM_: CHnXmlModelProvider::LogEventMapping OUT"));

    }

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

// 

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

// 

void CHnXmlModelProvider::LogSuiteModel( const TDesC& aName, 

                                                    RXmlEngDocument& aDoc )

    {

    DEBUG(("\t_MM_: CHnXmlModelProvider::LogSuiteModel IN"));

    TBuf8<256> buf1;

    TFileName logFileName;

    logFileName.Copy( KSuiteLoadingLogFile );

    logFileName.Append( Kbackslash );

    logFileName.Append( aName );

    logFileName.Append( KXmlExt );

    TRAP_IGNORE( aDoc.SaveL( logFileName, aDoc.DocumentElement() ) );

    DEBUG(("\t_MM_: CHnXmlModelProvider::LogSuiteModel OUT"));

    }

#endif

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

// 

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

//

RXmlEngDocument CHnXmlModelProvider::ParseFileL( const TDesC& aPath )

    {

    RBuf8 doc( ReadFileLC( aPath ) );

    CleanupClosePushL(doc);

    RXmlEngDocument xmlDoc;

    CleanupClosePushL( xmlDoc );

    xmlDoc = ParseDocL(doc);

    CleanupStack::Pop( &xmlDoc );

    // clean up

    CleanupStack::PopAndDestroy( &doc );

    return xmlDoc;

    }

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

// 

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

//

RXmlEngDocument CHnXmlModelProvider::ParseDocL( const TDesC8& aDoc )

    {

    RXmlEngDocument doc;

    CleanupClosePushL( doc );

    doc = iDomParser.ParseL( aDoc );

    CleanupStack::Pop( &doc );

    return doc;

    }

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

// 

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

//

HBufC8* CHnXmlModelProvider::ReadFileLC(const TDesC& aPath)

    {

    RFile file;

    User::LeaveIfError( file.Open(iFs, aPath, EFileRead) );

    CleanupClosePushL( file );

    TInt fileSize(0);

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

    HBufC8* buf = HBufC8::NewLC( fileSize );

    TPtr8 bufPtr( buf->Des() );

    User::LeaveIfError( file.Read( bufPtr ) );

    // clean up

    CleanupStack::Pop(buf);

    CleanupStack::PopAndDestroy(&file);    

    return buf;

    }

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

// 

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

//

void CHnXmlModelProvider::ChangeEventsToIdsInChildrenL(

		TXmlEngElement & aElement)

	{

	RXmlEngNodeList<TXmlEngElement> children;

	CleanupClosePushL(children);

	aElement.GetChildElements(children);

	TInt amount = children.Count();

	for (TInt i(0); i < amount; i++)

		{

		TXmlEngElement child = children.Next();

		TPtrC8 childName = child.Name();

				|| !child.Name().Compare(KMenuToolbar8))

			{

			ChangeEventNamesToIdsL(child);

			}

		else if (!childName.Compare(KEditModeItem8))

			{

			ChangeEventsToIdsInChildrenL(child);

			}

		}

	CleanupStack::PopAndDestroy(&children);

	}

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

// 

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

//

TInt CHnXmlModelProvider::CollectSuiteL(const TDesC& aSuiteName,

		RXmlEngDocument& aXmlDoc)

	{

	TInt err(KErrNotFound);

	TBuf<KMaxPath> filePath;

	TBuf<KMaxPath> KsuitePath;

	KsuitePath.Zero();

	KsuitePath.Copy(iPath);

	KsuitePath.Append(aSuiteName);

	KsuitePath.Append(Kbackslash);

	filePath.Zero();

	filePath.Copy(KsuitePath);

	filePath.Append(KSuiteDefFileName);

	RXmlEngDocument suiteDoc;

	CleanupClosePushL(suiteDoc);

	suiteDoc = ParseFileL(filePath);

    // one suite per file

    RXmlEngNodeList<TXmlEngElement> elements;

    suiteDoc.DocumentElement().GetChildElements( elements );

    TXmlEngElement suiteElement;

    while ( elements.HasNext() )

        {

        suiteElement = elements.Next();

        TPtrC8 t = suiteElement.Name();

        if ( !suiteElement.Name().Compare( KSuiteElementName8 ) )

            {

            ChangeEventsToIdsInChildrenL( suiteElement.AsElement() );    

            break;

            }

        }

    aXmlDoc.OpenL( iDomImpl, suiteDoc.DocumentElement() );            

    err = KErrNone;

    CleanupStack::PopAndDestroy( &suiteDoc );

    return err;             

    }

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

// 

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

//

TBool CHnXmlModelProvider::SuiteExistsL( const TDesC& aSuite )

    {

    TBuf<KMaxPath> filePath;

    TBuf<KMaxPath> KsuitePath;

    KsuitePath.Zero();

    KsuitePath.Copy( iPath );

    KsuitePath.Append( aSuite );

    KsuitePath.Append( Kbackslash );

    filePath.Zero();

    filePath.Copy( KsuitePath );

    filePath.Append( KSuiteDefFileName );

    return BaflUtils::FileExists( iFs, filePath );

    }

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

// 

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

//

void CHnXmlModelProvider::CollectItemsL( const TDesC& aSuiteName,

        RXmlEngDocument& aXmlDoc )

    {

    TBuf<KMaxPath> filePath;

    TBuf<KMaxPath> KsuitePath;

    KsuitePath.Zero();

    KsuitePath.Copy( iPath );

    KsuitePath.Append( aSuiteName ); 

    KsuitePath.Append( Kbackslash ); 

    CDir* fileList;                  

    iFs.GetDir( KsuitePath, KEntryAttMaskSupported, ESortByName, fileList);

    CleanupStack::PushL(fileList);

    //for each file with entries definitions         

    for( TInt i(0); i<fileList->Count(); i++ )  

        {            

        TPtrC fileName = (*fileList)[i].iName;   

        if(!fileName.Compare(KSuiteDefFileName))

            continue;

        filePath.Zero();

        filePath.Copy(KsuitePath);

        filePath.Append(fileName);  

        RXmlEngDocument itemDoc;

        CleanupClosePushL( itemDoc );

        TInt err( KErrNone );

        TRAP( err , itemDoc = ParseFileL(filePath) );

        if( !err )

            {

            RXmlEngNodeList< TXmlEngElement > children;

            CleanupClosePushL(children);

            itemDoc.DocumentElement().GetChildElements(children);

            TPtrC8 itemGenre =

                itemDoc.DocumentElement().AttributeNodeL(KGenreName8).Value();

            TInt amount = children.Count();

            for( TInt i(0); i<amount; i++ )

                {

                TXmlEngElement child = children.Next();

                TPtrC8 tempChildName = child.Name();

                // append localizations to root

                if (!child.Name().Compare(KLocalizationName8)) 

                    {                

                    aXmlDoc.DocumentElement().AsElement().AppendChildL(child);

                    child.ReconcileNamespacesL();

                    } 

                // append itmes to proper suite 

                else if (!child.Name().Compare(KItemName8) )

                    {                                    

                    // go througs item's children to change event names to ids

                    ChangeEventsToIdsInChildrenL(child);

                    // edit_mode item

                    RXmlEngNodeList< TXmlEngElement > editModeItems;

                    CleanupClosePushL( editModeItems );

                    child.GetChildElements( editModeItems );

                    TInt count = editModeItems.Count();

                    for ( TInt ic( 0 ); ic < count; ic++ )

                        {

                        TXmlEngElement editModeItem = editModeItems.Next();

                        if ( !editModeItem.Name().Compare( KEditModeItem8 ))

                            {

							editModeItem.AddNewAttributeL(KSuiteElementName8,

									itemGenre);

							}

						}

					CleanupStack::PopAndDestroy(&editModeItems);

					// edit_mode items - end

					RXmlEngNodeList<TXmlEngElement> suites;

					CleanupClosePushL(suites);

					aXmlDoc.DocumentElement().GetChildElements(suites);

					TInt amountSuites = suites.Count();

					for (TInt i(0); i < amountSuites; i++)

						{

						TXmlEngElement childSuite = suites.Next();

						TPtrC8 tempName = child.Name();

						//find suite

						if (!childSuite.Name().Compare(KTitleName8))

							{

							TPtrC8 suiteGenre = childSuite.AttributeNodeL(

									KGenreName8).Value();

							//find proper suite to append item

							if (!suiteGenre.Compare(itemGenre))

								{

								child.AddNewAttributeL(KSuiteElementName8,

										itemGenre);

								childSuite.AppendChildL(child);

                                }                        

                            }

                        }

					aXmlDoc.DocumentElement().ReconcileNamespacesL();

                    CleanupStack::PopAndDestroy( &suites );                    

                    }                                

                }                   

            CleanupStack::PopAndDestroy( &children );

            }

        CleanupStack::PopAndDestroy( &itemDoc );

        } 

    CleanupStack::PopAndDestroy(fileList);

    }        

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

// 

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

//

TInt CHnXmlModelProvider::GetNewEventId( HBufC* aEventName )

    {

    TInt res( KErrGeneral );

    if ( !aEventName->Compare( KKeyEmpty ) )

        {

        res = KKeyIdEmpty;

        }

    else if ( !aEventName->Compare( KKeySelect ) )

        {

        res = KKeyIdSelect;

        }

    else if ( !aEventName->Compare( KKeySelect2 ) )

        {

        res = KKeyIdSelect2;

        }

    else if ( !aEventName->Compare( KKeySelect3 ) )

        {

        res = KKeyIdSelect3;

        }