/*
* 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:  CCSXHLegacyContentParser class definition
*
*/

#include "CSXHLegacyContentParser.h"
#include "CSXHLegacyTOC1.h"
#include "CSXHLegacyTOC2.h"
#include "CSXHKywdTOC1.h"
#include "CSXHHelpDataBase.h"

#include <coehelp.h>
#include <coemain.h>
#include <f32file.h> 
#include <badesca.h>
#include <txtrich.h>

CCSXHLegacyContentParser* CCSXHLegacyContentParser::NewL(CCSXHHelpDataBase
*aDataBase)
    {
    CCSXHLegacyContentParser* self = CCSXHLegacyContentParser::NewLC(aDataBase);
    CleanupStack::Pop(self);
    return self;
    }
    
CCSXHLegacyContentParser* CCSXHLegacyContentParser::NewLC(CCSXHHelpDataBase
*aDataBase)
    {
    CCSXHLegacyContentParser* self = new (ELeave) CCSXHLegacyContentParser(aDataBase);
    CleanupStack::PushL(self);
    self->ConstructL();
    return self;
    }
    
void CCSXHLegacyContentParser::ConstructL()
    {
    iModel = CHlpModel::NewL(CCoeEnv::Static()->FsSession(), this);     
    iModel->OpenL();
    }
    
CCSXHLegacyContentParser::CCSXHLegacyContentParser(CCSXHHelpDataBase* aDataBase)
                        :iTopic(NULL)
    {
    iDataBase = aDataBase;
    iHlpList = NULL;
    }
    
CCSXHLegacyContentParser::~CCSXHLegacyContentParser()
    {
    if(iTopic)
        delete iTopic;
    if(iHlpList)
        delete iHlpList;
    
    //No need to delete the entries here, it will be done by the database
    iLegacyTOC1List.Close();    
    
    if(iModel)  
        {
        TRAP_IGNORE(iModel->CloseL());
        delete iModel;  
        }
    }
// --------------------------------------------------------------------------
// Gets the available kywds from the legacy content and sends them to the
// database
// --------------------------------------------------------------------------    
void CCSXHLegacyContentParser::GenerateKywdTOC1ListL(CCSXHHelpDataBase* aDataBase)
    {
    CHlpList* HlpList; 
    HlpList = CHlpList::NewL();
    iModel->SearchL(EIndexList);
    iModel->LoadListL(HlpList); 
    
    TInt nCount(HlpList->MdcaCount());
    for (TInt i(0); i < nCount; i++)
        {           
        TBuf<KMaxFileName> appName;
        appName = HlpList->MdcaPoint(i);
        TRAP_IGNORE(aDataBase->InsertKeywordL(appName,i,HlpList->Item(i)->HelpFileUid()));
        }   
    delete HlpList;
    }
// --------------------------------------------------------------------------
// Gets the available TOC1 from the legacy content and sends them to the
// database. Local copy of the TOC1 objects is maintained for generating TOC2
// --------------------------------------------------------------------------    
void CCSXHLegacyContentParser::GenerateTOC1ListL(CCSXHHelpDataBase* aDataBase)
    {    
    const TInt twoColumnFlatArray = 2;
    CDesCArray* categoryList = new(ELeave) CDesCArrayFlat(twoColumnFlatArray);
    CleanupStack::PushL(categoryList);
    iModel->CategoryListL(categoryList);
    CCSXHLegacyTOC1* categoryObj;
    TBuf<KMaxFileName> appName;
    TLinearOrder<CCSXHHelpContentBase> anOrder(Orderer<CCSXHHelpContentBase>);          
    for (TInt i(0); i < categoryList->Count(); i++)
        {           
        appName = categoryList->MdcaPoint(i);                           
        categoryObj = CCSXHLegacyTOC1::NewLC(appName);
        if ( aDataBase->GetAppHelpsTopics()->InsertChild(categoryObj) )
            {
            iLegacyTOC1List.AppendL(categoryObj);//Keep a local copy*/
            }
        CleanupStack::Pop(categoryObj);
        }
    CleanupStack::Pop(categoryList);            
    delete categoryList;
    }
// --------------------------------------------------------------------------
// Gets the available TOC2 objects for the TOC1 object
// --------------------------------------------------------------------------    
void CCSXHLegacyContentParser::GenerateTOC2ListL(CCSXHGenericTOC1& aGenericTOC1Object,
                                 RPointerArray<CCSXHHelpContentBase>* GenericTOC2List)
    {
    iModel->SearchL(ETopicListForCategory, aGenericTOC1Object.GetName());
    if(iHlpList)
        {
        delete iHlpList;
        //Next line is Needed for code scanner
        iHlpList = NULL;
        }
    iHlpList = CHlpList::NewL();
    iModel->LoadListL(iHlpList);
    
    TInt count(iHlpList->MdcaCount());
    CCSXHGenericTOC2* PLegacyTOC2;
    TLinearOrder<CCSXHHelpContentBase> anOrder(Orderer<CCSXHHelpContentBase>); 
    for (TInt i(0); i < count; i++)
        {    
        PLegacyTOC2 = CCSXHLegacyTOC2::NewL(&aGenericTOC1Object,iHlpList->MdcaPoint(i));
        if (KErrNone != GenericTOC2List->InsertInOrder(PLegacyTOC2,anOrder))
            delete PLegacyTOC2;
        }        
    }       
// --------------------------------------------------------------------------
// Gets the RTF content for the given topic
// --------------------------------------------------------------------------    
TAny* CCSXHLegacyContentParser::GetTopicContentL(CCSXHGenericTOC2* aTopic)
    {
    TInt nCount(iHlpList->MdcaCount());
    TInt nIndex(0);
    for(nIndex=0;nIndex < nCount; nIndex++)
        {
        TBuf<KMaxFileName> appName; 
        appName.Append(iHlpList->MdcaPoint(nIndex));
        if(appName.Compare(aTopic->GetName())==0)
            break;
        }
    if( nIndex == nCount )
        {
        return NULL;
        }
    if(iTopic)
        {
        delete iTopic;
        //Next line is Needed for code scanner
        iTopic = NULL;
        }
    iTopic = CHlpTopic::NewL();
    CHlpItem* item = iHlpList->Item(nIndex); 
    iModel->TopicSearchL(*item);    
    iModel->LoadTopicL(iTopic);    
    return iTopic->TopicText();    
    }

void CCSXHLegacyContentParser::HandleModelEventL(TInt aEvent)
    {
    iStatus = aEvent;   
    }

// --------------------------------------------------------------------------
// Gets the number of kywd subtopics for the given kywd
// --------------------------------------------------------------------------    
TInt CCSXHLegacyContentParser::InitGenerateTOC2ListForKeywordSearchL(CCSXHKywdTOC1* aKywdTOC1Object)
    {
    if(aKywdTOC1Object->LegacyIndex() == -1 || (!iLegacyTOC1List.Count()))      
        return 0;
    CHlpList* SearchList; 
    
    if(iHlpList)
        {
        delete iHlpList;
        //Next line is Needed for code scanner
        iHlpList = NULL;
        }
    iHlpList = CHlpList::NewL();
    SearchList = CHlpList::NewLC();
    iModel->SearchL(EIndexList);
    iModel->LoadListL(SearchList);  
    //Search Panel    
    CHlpItem* item = SearchList->Item(aKywdTOC1Object->LegacyIndex());
    iModel->IndexSearchL(*item);    
    iModel->LoadListL(iHlpList);        
    
    CleanupStack::PopAndDestroy(SearchList);
    return iHlpList->MdcaCount();
    }
    
    
// --------------------------------------------------------------------------
// Gets the available kywd subtopics for the given kywd
// --------------------------------------------------------------------------    
void CCSXHLegacyContentParser::GenerateTOC2ListForKeywordSearchL(CCSXHKywdTOC1* aKywdTOC1Object)
    {
    if(aKywdTOC1Object->LegacyIndex() == -1 || (!iLegacyTOC1List.Count()))      
        return;
    
    TInt nCount(iHlpList->MdcaCount());
    CCSXHGenericTOC2* PLegacyTOC2;
    TLinearOrder<CCSXHGenericTOC2> anOrder(Orderer<CCSXHGenericTOC2>); 
    for (TInt i(0); i < nCount; i++)
        {   
        PLegacyTOC2 = CCSXHLegacyTOC2::NewL(aKywdTOC1Object,iHlpList->MdcaPoint(i),ETrue);
        iDataBase->InsertKeywordTopic(aKywdTOC1Object,PLegacyTOC2);
        iDataBase->IncrementKeywordSearchCount();
        }    
  
    }
   
CCSXHLegacyTOC1* CCSXHLegacyContentParser::GetTOC1ForTOC2(CCSXHLegacyTOC2*)
    {
    TInt count = iLegacyTOC1List.Count();
    CCSXHLegacyTOC1* toc1; 
    for(TInt i = 0; i<count ; ++i)
        {
        toc1 = iLegacyTOC1List[i];
        if(iTopic->Category().Compare(toc1->GetName())==0)
            return toc1;
        }
    return NULL;    
    }
    
CCSXHHelpContentBase* CCSXHLegacyContentParser::GetContextTopic(TCoeHelpContext& aContext)
    {
        TRAPD(err,LoadContextTopicL(aContext));
        if(err != KErrNone || NULL == iTopic)
            return NULL;
        
        TInt count = iLegacyTOC1List.Count();
        CCSXHLegacyTOC1* toc1; 
        for(TInt i = 0; i<count ; ++i)
            {
            toc1 = iLegacyTOC1List[i];
            if(iTopic->Category().Compare(toc1->GetName())==0)
                {
                return toc1->GetContextTopic(iTopic->TopicTitle());
                }
            }
        return NULL;
    }

void CCSXHLegacyContentParser::LoadContextTopicL(TCoeHelpContext& aContext)
    {
    if(iTopic)
        {
        delete iTopic;
        //Next line is Needed for code scanner
        iTopic = NULL;
        }
    
    iModel->ContextSearchL(aContext);
    if(ETopicAvailable == iStatus )
        {
        iTopic = CHlpTopic::NewL();
        iModel->LoadTopicL(iTopic);     
        }
    }