/*

* 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();

    TBool dirExists = iIndexing->IndexFileExists();

    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 );

            TInt dirChanged = iIndexing->CheckDirChange( 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

                    iIndexing->DeleteIndexFile( driveLetter );

                    }

                }

            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

                    iIndexing->BeginIndexFile( driveLetter );

                    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 );

    iIndexing->AppendLocale( masterFile );

    masterFile.Append( KMasterMetaFile );

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

        {

#ifdef _DEBUG

        RDebug::Print(_L("index exist begin to parse!    %c"), 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,

                                                                 CCSXHXMLParseHandler* XMLParser

                                                                  )

    {

     CDir* entryList = NULL;

    scanner->NextL(entryList);

    if(!entryList)

        return;

    CleanupStack::PushL(entryList);

    TInt entryCount = entryList->Count();           

    TLinearOrder<CCSXHHelpContentBase> anOrder(Orderer<CCSXHHelpContentBase>); 

    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))

					{

		            CCSXHHtmlTOC1* CategoryObj = CCSXHHtmlTOC1::NewL(

		                                        XMLParser->GetApplicationName(),entry.iName,aDrive);

		            iIndexing->RuntimeGenerateIndexL( *CategoryObj, XMLParser->GetFeatureIds() );

		            if(CategoryObj && aDataBase->GetMainTopics()->InsertChild(CategoryObj,EFalse))

		            	iHtmlTOC1List.Append(CategoryObj);//Keep a local copy*/ 

					else

						{

						if(CategoryObj)  

		            		iDuplicateHelpTopicList.Append(CategoryObj);	

						}			            	

					}

            	}         

            }

        }       

    CleanupStack::PopAndDestroy(entryList);

    }

void CCSXHHTMLContentParser::InsertHTMLToc1L(

            const TDesC &appUidName,const TDesC &appName, 

            const TInt& aDrive , CCSXHHelpDataBase* aDataBase, const TDesC &FeatureIds)

    {

	if(CheckFeatureIDL(FeatureIds))

	    {

	    if(!IsAppUIdPresentAlready(appUidName)) 

		    {    

			CCSXHHtmlTOC1* CategoryObj = CCSXHHtmlTOC1::NewL(appName,appUidName,aDrive);

		    if(CategoryObj && aDataBase->GetMainTopics()->InsertChild(CategoryObj,EFalse))

		    	iHtmlTOC1List.Append(CategoryObj);//Keep a local copy*/ 

		    else

		    	{

		    	if(CategoryObj)  

	           		iDuplicateHelpTopicList.Append(CategoryObj);			    	

		    	}

		    }

	    }	

    }

HBufC8* CCSXHHTMLContentParser::GetContentsFromFileL(const TDesC& htmlFile,CCoeEnv* aCoeEnv,

			RFeatureControl& aFeatureControl) 

    {

    RFs& fileSession = aCoeEnv->FsSession();        

    TInt SlashPosition = htmlFile.LocateReverse('\\');    

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

    CleanupStack::PushL(CompressedFile); //1

    CompressedFile->Copy(htmlFile.Mid(0,SlashPosition+1));

    CompressedFile->Append(KContentZipFile);    

    HBufC8* CssContent = CreateBufferForCSSContentL(aFeatureControl);

    if(!BaflUtils::FileExists(fileSession,*CompressedFile))

        {

        CleanupStack::PopAndDestroy(CompressedFile);

        HBufC8* buffer = GetContentsFromHTMLFileL(htmlFile,aCoeEnv);

        return MergeCssAndHTMLContentL(buffer,CssContent);

        }

    // Create an instance of CZipFile.

    CZipFile* zipFile = CZipFile::NewL(fileSession, *CompressedFile);    

    CleanupStack::PushL(zipFile); //2

    // Iterate and get the file name

    CZipFileMemberIterator* members = zipFile->GetMembersL();

    CleanupStack::PushL(members);//3

    CZipFileMember* member = members->NextL(); // Get the first file in zip

    TInt nCount=0;    

    const TBuf<KMaxFileName>*Fname;

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

    CleanupStack::PushL(HtmlFileName); //4

    HtmlFileName->Copy(htmlFile.Mid(SlashPosition+1));

    for(nCount=0;member!=NULL;nCount++)

    	{    	 

    	 Fname = member->Name();    

	     if(Fname->Compare(*HtmlFileName)==0 )

	    	{

	    	break;

	    	}	    

	    delete member;	

    	member = members->NextL();    	

    	}

	if(NULL == member)

		{

		CleanupStack::PopAndDestroy(HtmlFileName);

		CleanupStack::PopAndDestroy(members);

	    CleanupStack::PopAndDestroy(zipFile);

	    CleanupStack::PopAndDestroy(CompressedFile);

	    HBufC8* buffer = GetContentsFromHTMLFileL(htmlFile,aCoeEnv);

	    return MergeCssAndHTMLContentL(buffer,CssContent);

	    }

    CleanupStack::PushL(member);//5

    RZipFileMemberReaderStream* stream;

    zipFile->GetInputStreamL(member, stream);

    CleanupStack::PushL(stream);//6

    // Extracts aFileName to a buffer.

    // If the file is quite huge, then read the file in streaming mode.

    // For example, use 4KB buffer and read it in an active object.

    HBufC8* buffer = HBufC8::NewLC(member->UncompressedSize());//5

    TPtr8 bufferPtr(buffer->Des());

    User::LeaveIfError(stream->Read(bufferPtr, member->UncompressedSize()));

    // Release all the resources.   

    CleanupStack::Pop(buffer);

    CleanupStack::PopAndDestroy(stream); 

    CleanupStack::PopAndDestroy(member);

    CleanupStack::PopAndDestroy(HtmlFileName);

    CleanupStack::PopAndDestroy(members);

    CleanupStack::PopAndDestroy(zipFile);

    CleanupStack::PopAndDestroy(CompressedFile);

    return MergeCssAndHTMLContentL(buffer,CssContent);

    }

TBool CCSXHHTMLContentParser::HandleMasterKeywordFileL(CCSXHHelpDataBase* aDataBase)

    {

    RFs& FileSession = iCoeEnv->FsSession();

    CCSXHXMLParseHandler_MasterKywd* XMLParser_MasterKywd = CCSXHXMLParseHandler_MasterKywd::NewL(iCoeEnv);  

    CleanupStack::PushL(XMLParser_MasterKywd);  

    InitializeReaderL(XMLParser_MasterKywd);

    XMLParser_MasterKywd->SetHtmlContentParserPtr(this);

    XMLParser_MasterKywd->SetDataBasePtr(aDataBase);

    TBool bMasterKeywordFilePresent = EFalse;

    //Check for the availability of Master Keyword file

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

    CleanupStack::PushL(Master_kywdPath);//5

    Master_kywdPath->Append(PathInfo::RomRootPath().Left(1));

    GetHTMLContentPathForDriveL(Master_kywdPath,iCoeEnv);

    Master_kywdPath->Append(KMasterKywdFile);

    if(BaflUtils::FileExists(FileSession,*Master_kywdPath))

    	{    	

        TRAP_IGNORE(iXmlReader->ParseL(FileSession,*Master_kywdPath ));

        bMasterKeywordFilePresent = ETrue;

    	}    

    //KMasterKywdFile;

    CleanupStack::PopAndDestroy(Master_kywdPath);

    CleanupStack::PopAndDestroy(XMLParser_MasterKywd);

    ClearReader();	

    return bMasterKeywordFilePresent;

    }

void CCSXHHTMLContentParser::GenerateKywdTOC1ListL(CCSXHHelpDataBase* aDataBase)

    {

    if(!iHtmlTOC1List.Count())

        return;

    TBool bMasterKeywordFilePresent = HandleMasterKeywordFileL(aDataBase);

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

    CleanupStack::PushL(XMLParser);  

    InitializeReaderL(XMLParser);

    XMLParser->SetDataBasePtr(aDataBase);

    XMLParser->SetIsTOC2(EFalse);

    XMLParser->SetHtmlContentParserPtr(this);

    //Parse keyword.xml file from Main Array list

    ParseKeywdFileAndCreatekywdTOC1ObjectsL(iHtmlTOC1List,XMLParser,bMasterKeywordFilePresent);

    //Parse keyword.xml file from duplicate Array list

    ParseKeywdFileAndCreatekywdTOC1ObjectsL(iDuplicateHelpTopicList,XMLParser,bMasterKeywordFilePresent);

    CleanupStack::PopAndDestroy(XMLParser);

    ClearReader();