/*

* Copyright (c) 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:  CCSXHHTMLContentParser class definition

*

*/

#include "CSXHHTMLContentParser.h"

#include "CSXHXMLParseHandler.h"

#include "CSXHHtmlTOC1.h"

#include "CSXHKywdTOC1.h"

#include "CSXHHtmlTOC2.h"

#include "CSXHHelpDataBase.h"

#include "csxhconstants.h"

#include "CSXHRuntimeIndexing.h"

#include <eikenv.h> 

#include <utf.h>

#include <data_caging_path_literals.hrh>

#include <zipfile.h>

#include <bautils.h>

#include <SenXmlReader.h> 

#include <f32file.h>

#include <pathinfo.h> 

//Input Language variation changes

#include <PtiEngine.h>

const TInt KOffset = 2;

CCSXHHTMLContentParser* CCSXHHTMLContentParser::NewL(CCoeEnv* aCoeEnv)

    {

    CCSXHHTMLContentParser* self = CCSXHHTMLContentParser::NewLC(aCoeEnv);

    CleanupStack::Pop(self);

    return self;

    }

CCSXHHTMLContentParser* CCSXHHTMLContentParser::NewLC(CCoeEnv* aCoeEnv)

    {

    CCSXHHTMLContentParser* self = new (ELeave) CCSXHHTMLContentParser(aCoeEnv);

    CleanupStack::PushL(self);

    self->ConstructL();

    return self;

    }

void CCSXHHTMLContentParser::ConstructL()

    {

    //RUNTIME

    GetSupportedFeatureListL();

    }

CCSXHHTMLContentParser::CCSXHHTMLContentParser(CCoeEnv* aCoeEnv) : iCoeEnv(aCoeEnv)

    {

    }

CCSXHHTMLContentParser::~CCSXHHTMLContentParser()

    {

    delete iXmlReader;

    //No need to delete the entries here, it will be done by the database

    iHtmlTOC1List.Close();

    //Delete all contents from the array.

    TInt count =    iDuplicateHelpTopicList.Count();

    CCSXHHtmlTOC1* toc1;

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

        {

        toc1 = iDuplicateHelpTopicList[i];

        delete toc1;

        }

    iDuplicateHelpTopicList.Reset();    

	iDuplicateHelpTopicList.Close();

    // Closes the array and frees all memory allocated to the array.

   // iSupportedFeatures.Close();

    delete iSupportedInputLanguages;

    delete iFeatureManager_FeatureIds;

    delete iIndexing;

    }

void CCSXHHTMLContentParser::GenerateTOC1ListL(CCSXHHelpDataBase* aDataBase)

    {       

    RFs& FileSession = iCoeEnv->FsSession();

    TDriveList DirList; 

    if(FileSession.DriveList(DirList) != KErrNone)

        return; 

    CCSXHXMLParseHandler_MetaFile* XMLParser = CCSXHXMLParseHandler_MetaFile::NewL(iCoeEnv); 

    CleanupStack::PushL(XMLParser);   

    InitializeReaderL(XMLParser);

    TBuf<KMaxFileName>* rootDir = new(ELeave) TBuf<KMaxFileName>;

    CleanupStack::PushL(rootDir);//5

    // begin runtime index XML generating

    //   

    iIndexing = CCSXHRuntimeIndexing::NewL();

    TInt driveListSize = DirList.Length();

    CDirScan* scanner=CDirScan::NewLC(FileSession);

#ifdef _DEBUG

    RDebug::Print(_L("runtime indexing object successfully build"));

#endif

    for(TInt dir(0); dir < driveListSize; dir++)

        {

        TInt error;

        TDriveInfo info;

        TChar driveLetter = '?';

        error = FileSession.Drive(info, dir);

        if  ( ( error == KErrNone ) && 

                (DirList[dir] && info.iType != EMediaNotPresent))

            {

            RFs::DriveToChar( dir, driveLetter );

            rootDir->Delete( 0, rootDir->Length() );//Clear the previous contents                  

            rootDir->Append( driveLetter );

            if  ( dirExists 

                    && ( dirChanged == KNoChange

                        || dirChanged == KNoDirExist) )

                {

                // xml exist and no install/uninstall happened

                // while Z needs special process once its index file exists

#ifdef _DEBUG

                RDebug::Print(_L("Used to launch, scan drive number:  %d"), dir);

#endif

                if ( dirChanged == KNoChange )

                    {

                    // no modify helps, so just parse index.xml

                    //

                    HandleMasterMetaFileL( aDataBase, driveLetter, XMLParser );

                    }

                else // KNoDirExist

                    {

                    // help content folder removed due to some reason (uninstall/crash?)

                    // delete index file in case it exist

#ifdef _DEBUG

                    RDebug::Print( _L("no resource folder, delete index.xml if exists") );

#endif

                    }

                }

            else

                {

                // xml not exist or install/uninstall not happend

                //

                if( GetHTMLContentPathForDriveL( rootDir,iCoeEnv ) )

                    {

#ifdef _DEBUG

                    RDebug::Print( _L("No index, scan folder for parsing, drive letter: %d"), dir );

#endif

                    scanner->SetScanDataL(*rootDir

                                    ,KEntryAttDir|KEntryAttMatchExclusive,

                                    ESortByName|EAscending, CDirScan::EScanDownTree);

                    ScanAndParseXMLfileToCreateTOC1ObjectL(FileSession,scanner,aDataBase,

                                                        dir,XMLParser);  

                    iIndexing->FinishAndCloseIndexFileL();

                    }

                }

            }

        }

    CleanupStack::PopAndDestroy( scanner );

    CleanupStack::PopAndDestroy(rootDir);

    CleanupStack::PopAndDestroy(XMLParser);

    ClearReader();

    }

TBool CCSXHHTMLContentParser::GetHTMLContentPathForDriveL(TBuf<KMaxFileName>* aContentDrive,CCoeEnv *aCoeEnv)

	{

    // get the path to language level

    // Input: aContentDrive == C or E or Z

    // Output: aContentDrive == C:\\resource\\xhtml\\01\\ (or Z:\\resource\\xhtml\\31\\)

    //

	aContentDrive->Append(KXhtmlFolder);

	TInt len = aContentDrive->Length();

	RFs& FileSession = aCoeEnv->FsSession();

	RArray<TLanguage> langs;

   	BaflUtils::GetDowngradePathL(FileSession,User::Language(),langs);

    for(int i = 0; i < langs.Count(); ++i)

    	{

    	TLanguage lang = langs[i];

    	//TSW Error: UKAL-6YL72P

    	//Tool chain uses full symbian language id in 

    	//the directory name, which is not detected by help application.

    	//

    	if(lang < 10)

            {

            aContentDrive->AppendNumFixedWidth(lang,EDecimal,2);

            }

        else

            {

            aContentDrive->AppendNum(lang);

            }

    	aContentDrive->Append(KFwdSlash);

    	if(BaflUtils::PathExists(FileSession,*aContentDrive))

    		{

    		langs.Reset();

    		return ETrue;

    		}

    	else

    		{

    		aContentDrive->Delete((len-1),aContentDrive->Length()-len);

    		}	

    	}

    	langs.Reset();

    	return EFalse;

	}

TBool CCSXHHTMLContentParser::HandleMasterMetaFileL(CCSXHHelpDataBase* aDataBase, 

                        TChar& aDrive, MSenContentHandlerClient *aPrevHandler)											   

    {

    RFs& FileSession = iCoeEnv->FsSession();

    TBuf<KMaxFileName> masterFile;

    iIndexing->GetPrivatePath( masterFile );

    masterFile.Append( aDrive );

    masterFile.Append( KFwdSlash );

    masterFile.Append( KMasterMetaFile );

    if(BaflUtils::FileExists( FileSession,masterFile ) )

        {

#ifdef _DEBUG

        RDebug::Print(_L("index exist begin to parse!    %c"), TUint( aDrive ) );

#endif

        CCSXHXMLParseHandler_MasterMetaFile* masterMetaHandler = 

        CCSXHXMLParseHandler_MasterMetaFile::NewL(iCoeEnv);

        masterMetaHandler->SetDataBasePtr(aDataBase);

        masterMetaHandler->SetHtmlContentParserPtr(this);

        CleanupStack::PushL(masterMetaHandler);      

        iXmlReader->SetContentHandler(*masterMetaHandler);

        // ParseL is not in async

        iXmlReader->ParseL(FileSession,masterFile);

        iXmlReader->SetContentHandler(*aPrevHandler);

        CleanupStack::PopAndDestroy(masterMetaHandler);

        }

    return ETrue;

    }

void CCSXHHTMLContentParser::GenerateTOC2ListL(CCSXHGenericTOC1& 

aGenericTOC1Object, RPointerArray<CCSXHHelpContentBase>* GenericTOC2List)

    {

    CCSXHXMLParseHandler_IndexFile* XMLParser = CCSXHXMLParseHandler_IndexFile::NewL(iCoeEnv);

    CleanupStack::PushL(XMLParser);      

    InitializeReaderL(XMLParser);

    XMLParser->SetArray(GenericTOC2List);

    XMLParser->SetGenericTOC1Object(aGenericTOC1Object);

    XMLParser->SetHtmlContentParserPtr(this);

    RFs& FileSession = iCoeEnv->FsSession();

    CCSXHHtmlTOC1* toc1 = STATIC_CAST(CCSXHHtmlTOC1*,&aGenericTOC1Object);

    TBuf<KMaxFileName> lookupindexfile;

    toc1->GetHelpFileL(lookupindexfile);

    XMLParser->SetPath(lookupindexfile);

    lookupindexfile.Append(KIndexFile);              

    if(BaflUtils::FileExists(FileSession,lookupindexfile))

        iXmlReader->ParseL (FileSession,lookupindexfile);

	TBuf<KMaxFileName>HelpContentName(toc1->GetName());

	int toc1Count = iDuplicateHelpTopicList.Count();

 	for(int i=0;i < toc1Count;i++)

	    {    

	    CCSXHHtmlTOC1* temptoc1 = iDuplicateHelpTopicList[i];

	    if(temptoc1->GetName().CompareF(HelpContentName) == 0)

		    {    

		    TBuf<KMaxFileName> lookup;

		    temptoc1->GetHelpFileL(lookup);

		    XMLParser->SetPath(lookup);

		    lookup.Append(KIndexFile);              

		    if(BaflUtils::FileExists(FileSession,lookup))

		        iXmlReader->ParseL (FileSession,lookup);

		    }

	    }

    CleanupStack::PopAndDestroy(XMLParser);

    ClearReader();

    }       

TAny* CCSXHHTMLContentParser::GetTopicContentL(CCSXHGenericTOC2* aTopic)

    {

    CCSXHHtmlTOC2* topic = STATIC_CAST(CCSXHHtmlTOC2*,aTopic);

    TBuf<KMaxFileName> htmlFile;

	topic->GetHtmlFileName(htmlFile);

    return GetContentsFromFileL(htmlFile,iCoeEnv,iFeatureControl);

    }

void CCSXHHTMLContentParser::ScanAndParseXMLfileToCreateTOC1ObjectL(RFs& FileSession,

                                                                 CDirScan* scanner,

                                                                 CCSXHHelpDataBase* aDataBase,

                                                                 const TInt& aDrive,

                                                                  )

    {

     CDir* entryList = NULL;

    scanner->NextL(entryList);

    if(!entryList)

        return;

    CleanupStack::PushL(entryList);

    TInt entryCount = entryList->Count();           

    TBuf<KMaxFileName> lookup;

    while(entryCount--)

        {

        TEntry entry=(*entryList)[entryCount];

        //Clear the previous values

        lookup.Delete(0,lookup.Length());

        lookup.Append(scanner->FullPath());

        lookup.Append(entry.iName); 

        lookup.Append(KFwdSlash);

        lookup.Append(KMetaFile);

        //Check whether a file exists        

        if(!BaflUtils::FileExists(FileSession,lookup))

            continue;

        TRAPD(parserResult,iXmlReader->ParseL (FileSession,lookup ));

        if(parserResult == KErrNone)

            {

			if(CheckFeatureIDL(XMLParser->GetFeatureIds()))

            	{            

            	if(!IsAppUIdPresentAlready(entry.iName))

					{

		                {

		                }

            	}         

            }

        }       

    CleanupStack::PopAndDestroy(entryList);

    }

void CCSXHHTMLContentParser::InsertHTMLToc1L(

            const TDesC &appUidName,const TDesC &appName, 

    {

	if(CheckFeatureIDL(FeatureIds))

	    {

	    if(!IsAppUIdPresentAlready(appUidName))