/*

* 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 "CSXHViewIDs.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->IndexFileExistsL();

    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->CheckDirChangeL( 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->DeleteIndexFileL( 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->BeginIndexFileL( 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->AppendLocaleL( masterFile );

    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;

    }

TBool CCSXHHTMLContentParser::IsRedirectedL(CCSXHHelpDataBase *aDataBase, 

                              const TDesC &aPath, TUid &aUid, TCoeContextName &aContextName)                                               

    {

    RFs& FileSession = iCoeEnv->FsSession();

    TBuf<KMaxFileName> redirectFile( aPath );

    redirectFile.Append( KRedirectFile );

    TBool result = EFalse;

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

        {

        CCSXHXMLParseHandler_RedirectFile* XMLParser = 

                     CCSXHXMLParseHandler_RedirectFile::NewL(iCoeEnv, aUid, aContextName);

        XMLParser->SetDataBasePtr( aDataBase );

        CleanupStack::PushL( XMLParser );      

        InitializeReaderL( XMLParser );

        // ParseL is not in async

        iXmlReader->ParseL( FileSession, redirectFile );

        if ( XMLParser->IsTargetPathFound() )

            {

            TBuf<KMaxFileName>& targetContextName = XMLParser->TargetContextName();

            if ( targetContextName.Length() <= aContextName.MaxLength() )

                {

                aUid = XMLParser->TargetUid();

                aContextName = targetContextName;

                result = ETrue;

                }

            }

        CleanupStack::PopAndDestroy( XMLParser );

        ClearReader();

        }

    return result;

    }

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_MetaFile* XMLParser

        )

    {

    CDir* entryList = NULL;

    scanner->NextL(entryList);

    if (!entryList)

        {

        return;

        }

    CleanupStack::PushL(entryList);

    TInt entryCount = entryList->Count();     

    TInt ROMDrive;

    RFs::CharToDrive(PathInfo::RomRootPath()[0], ROMDrive);

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

                    {

                    TBool isRomBased = EFalse;

                    TInt32 priority = XMLParser->Priority();

                    // Now we take a walk if it's application helps (priority == 0)

                    if ((priority != 0) 

                        && ((aDrive == ROMDrive) || IsRomBasedContentL(FileSession, entry.iName)))

                        {

                        if (priority < KHighestPriority)

                            {

                            priority = KHighestPriority;

                            }

                        else if (priority > KLowestPriority)

                            {

                            priority = KLowestPriority;

                            }

                        isRomBased = ETrue;

                        }

                    else 

                        {

                        priority = 0;

                        }

                    CCSXHHtmlTOC1* categoryObj = CCSXHHtmlTOC1::NewL(XMLParser->GetApplicationName(), entry.iName, aDrive, 

                            isRomBased ? KCSXHToc2ViewID : KCSXHToc2AppHelpsViewID, priority);

                    if (!categoryObj->IsValid())

                        {

                        delete categoryObj;

                        }

                    else

                        {

                        CleanupStack::PushL(categoryObj);

                        if (isRomBased)

                            {

                            if (aDataBase->GetMainTopics()->InsertChildWithPriority(categoryObj, EFalse))

                                {

                                iHtmlTOC1List.AppendL(categoryObj);

                                }

                            else

                                {

                                iDuplicateHelpTopicList.AppendL(categoryObj);

                                }

                            }

                        else

                            {

                            if (aDataBase->GetAppHelpsTopics()->InsertChild(categoryObj, EFalse))

                                {

                                iHtmlTOC1List.AppendL(categoryObj);

                                }

                            else

                                {

                                iDuplicateHelpTopicList.AppendL(categoryObj);

                                }

                            }

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

                        CleanupStack::Pop(categoryObj);

                        }

                    }

                }         

            }

        }       

    CleanupStack::PopAndDestroy(entryList);

    }

TBool CCSXHHTMLContentParser::IsRomBasedContentL( RFs& FileSession, const TDesC &aUid )

    {

#ifdef __WINSCW__

    return ETrue;

#endif

    TBool result = EFalse;

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

    TBuf<KMaxFileName> rootDir;

    rootDir.Append( 'z' );

    if( GetHTMLContentPathForDriveL( &rootDir,iCoeEnv ) )

        {

        scanner->SetScanDataL(rootDir,KEntryAttDir|KEntryAttMatchExclusive,

                                        ESortByName|EAscending, CDirScan::EScanDownTree);

        CDir* entryList = NULL;

        scanner->NextL(entryList);

        if ( !entryList )

            {

            CleanupStack::PopAndDestroy( scanner );

            return EFalse;

            }

        TInt entryCount = entryList->Count();           

        while ( entryCount-- )

            {

            TEntry entry=(*entryList)[entryCount]; 

            if ( ( entry.iName ).CompareC(aUid) == 0 )

                {

                result = ETrue;

                break;

                }

            }

        delete entryList;

        }

    CleanupStack::PopAndDestroy( scanner );

    return result;

    }

void CCSXHHTMLContentParser::InsertHTMLToc1L(

        const TDesC& aAppUidName,

        const TDesC& aAppName, 

        const TInt& aDrive,

        CCSXHHelpDataBase* aDataBase, 

        const TDesC& aFeatureIds, 

        TInt32 aPriority

        )

    {

    if (CheckFeatureIDL(aFeatureIds))

        {

        if (!IsAppUIdPresentAlready(aAppUidName)) 

            {

            // Now we take a walk if it's application helps (priority == 0)

            CCSXHHtmlTOC1* categoryObj = CCSXHHtmlTOC1::NewL(aAppName,aAppUidName, aDrive,

                    aPriority == 0 ? KCSXHToc2AppHelpsViewID : KCSXHToc2ViewID, aPriority);

            if (categoryObj->IsValid())

                {

                CleanupStack::PushL(categoryObj);

                if (aPriority == 0)

                    {

                    if (aDataBase->GetAppHelpsTopics()->InsertChild(categoryObj, EFalse))

                        {

                        iHtmlTOC1List.AppendL(categoryObj);

                        }