/*

* Copyright (c) 2006-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:           

*

*/

#include <e32std.h>

#include <utf.h>

#include <sysutil.h>

#include <ezcompressor.h>

#include "wsstardictionary.h"

#include "wsstarhttpclient.h"

#include "wsstarpolicy.h"

#include "sendebug.h"

#include "senxmldebug.h"

#include "senlogger.h"

using namespace WSPolicy;

namespace

{

    _LIT8(KHttp, "http");

    _LIT(KDictionaryFile, "dictionary.xml");

    _LIT8(KDictionaryType, "Type");

    _LIT8(KDictionaryId, "Id");

    _LIT8(KDictionaryChkSum, "Chksum");

    // helper methods          

    /*

    void TUint32ToDes(TDes8& aResult, TUint32 aData)

        {

        TUint32 part1= aData & 0xff000000 ;

        part1 = part1 >> 24;

        TUint32 part2= aData & 0x00ff0000;

        part2 = part2 >> 16;

        TUint16 part3= aData & 0x0000ff00;

        part3 = part3 >> 8;

        TUint16 part4= aData & 0x000000ff;

        TUint8 p1(part1);

        TUint8 p2(part2);

        TUint8 p3(part3);

        TUint8 p4(part4);

        aResult.Append(p1);

        aResult.Append(p2);

        aResult.Append(p3);

        aResult.Append(p4);

        }

    */

    /*

    TUint32 DesToTUint32(const TDesC8& aData)

        {

        TUint32 part1 = aData[0];

        part1 = part1-48;

        part1 = part1 << 24;

        TUint32 part2 = aData[1];

        part2 = part2-48;

        part2 = part2 << 16;

        TUint32 part3 = aData[2];

        part3 = part3-48;

        part3 = part3 << 8;

        TUint32 part4 = aData[3];

        part4 = part4-48;

        TUint32 ret = part1+part2+part3+part4;

        return ret;

        }

    */      

}

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

// Create instance of this class

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

//

CWSStarDictionary* CWSStarDictionary::NewL(CSIF& aSIF, RFileLogger& aLogger)

    {

    CWSStarDictionary* self   = new (ELeave) CWSStarDictionary(aSIF, aLogger);

    CleanupStack::PushL (self);

    self->ConstructL();

    CleanupStack::Pop(self);

    return self;

    }

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

// Constructor

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

//

CWSStarDictionary::CWSStarDictionary(CSIF& aSIF, RFileLogger& aLogger) 

:iSIF(&aSIF), iLog(aLogger)

    {

    }

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

// Destructor

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

//

CWSStarDictionary::~CWSStarDictionary()

    {

    TLSLOG(KSenCoreServiceManagerLogChannelBase  , KMinLogLevel,(_L("CWSStarDictionary::~CWSStarDictionary()")));

    iDictionaires.ResetAndDestroy();

    delete iSavePath;

    }

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

// void CWSStarDictionary::ConstructL()

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

//

void CWSStarDictionary::ConstructL()

    {   

     TLSLOG(KSenCoreServiceManagerLogChannelBase  , KMinLogLevel,(_L("CWSStarDictionary::ConstructL()")));

#if !defined( EKA2 ) && !defined( RD_SECURE_PRIV_DATA )

        iSavePath = KPrivateFolder().AllocL();

#else

        TBuf<KMaxPath> privatePath;

        RFs fss;

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

            CleanupClosePushL(fss);

        fss.CreatePrivatePath(EDriveC);

        fss.PrivatePath(privatePath);

        iSavePath = privatePath.AllocL();

        CleanupStack::PopAndDestroy(1);

#endif

    }

CZlibDictionary* CWSStarDictionary::Dictionary(const TDesC8& aName)

{

    TInt count(iDictionaires.Count());

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

    {

        CZlibDictionary* tempDict = iDictionaires[i];

        if(tempDict->DictName() == aName)

        {

          return tempDict;  

        }

    }

    return NULL;

}    

TBool CWSStarDictionary::IfDictionaryExist(CZlibDictionary* aDict)

{

    TInt count(iDictionaires.Count());

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

    {

        CZlibDictionary* tempDict = iDictionaires[i];

        if(tempDict->DictName() == aDict->DictName() &&  

        tempDict->DictCheckSumPtr() == aDict->DictCheckSumPtr()

        ) //Id and checksum is same, its same dictionary

        {

          return ETrue;  

        }

    }

    return EFalse;

}

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

// void CWSStarDictionary::CreateZlibL

// create a CZlibDictionary object from given dictionary inforamtion

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

//

void CWSStarDictionary::CreateMSZlibL(const TDesC8* name, CSenElement* aDict)

{

    const TDesC8* type = aDict->AttrValue(KMwsType);

    const TDesC8* checksum = aDict->AttrValue(KMwsId);

   if(aDict->HasContent())

    {

        TPtrC8 uri = aDict->Content();

        if(name && type && checksum && uri!= KNullDesC8())

        {

            CZlibDictionary* dict = CZlibDictionary::NewLC(uri, name, type, checksum);

            if(dict)

            {

                if(!IfDictionaryExist(dict))

                {

                    iDictionaires.Append(dict);    

                    CleanupStack::Pop( dict );                    

                }

                else //exist

                {

//                Reset only when we know that the uri has been changed

                    CZlibDictionary* tempDict = Dictionary(dict->DictName());

                    if(tempDict)                     

                    {

                        if( tempDict->DictUri() == dict->DictUri()

//                         && tempDict->DictType() == dict->DictType()

                            )

                        {

                            //do nuthhing

                        }

                        else

                        {

                            tempDict->ResetL(dict);

                        }

                    }

                    CleanupStack::PopAndDestroy( dict );

                }

            }

            else

            {

                CleanupStack::PopAndDestroy( dict );

            }

        }

    }    

}

void CWSStarDictionary::CreateZlibL(const TDesC8* name, CSenElement* aDict)

{

    if(!name || ! aDict)

        return;

    const TDesC8* type = aDict->AttrValue(KDictionaryType);

    const TDesC8* checksum = aDict->AttrValue(KDictionaryChkSum);

   if(aDict->HasContent())

    {

        TPtrC8 uri = aDict->Content();

        if(name && type && checksum && uri!= KNullDesC8())

        {

            CZlibDictionary* dict = CZlibDictionary::NewLC(uri, name, type, checksum);

            if(dict && !IfDictionaryExist(dict))

            {

                iDictionaires.Append(dict);

                CleanupStack::Pop( dict );

            }

            else

            {

                CleanupStack::PopAndDestroy( dict );

            }

        }

    }    

}

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

// TInt CWSStarDictionary::InvokeL

// This method invoke the Http download of dictionaries. The dictionaries will 

// be downloaded adn saves to private folder of the serene

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

//

TInt CWSStarDictionary::InvokeL(MSenHandlerContext* iHndlrCtx, CSenWSDescription* aSD)

    {

    TLSLOG(KSenCoreServiceManagerLogChannelBase  , KMinLogLevel,(_L("CWSStarDictionary::InvokeL(MSenMessageContext& aCtx)")));

    TInt error(KErrNotFound);

//1..load dictionary.xml file

//2..load all of dictionaries and verify it

    LoadDictionariesL();

//3..get dictionary element from policy

//only sts policy will be considered at this point

   CSenElement* ret = CWSStarPolicy::GetElementL(KDictionaries, KNullDesC8(), *iHndlrCtx, aSD);

    if(ret)

    {

        RPointerArray<CSenElement>& children = ret->ElementsL();

        TInt count = children.Count();

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

        {

            CSenElement* ele = children[i];

            if(ele)

            {

                const TDesC8* name = ele->AttrValue(KMwsId);

                RPointerArray<CSenElement> dicts;

                CleanupClosePushL(dicts);

                ele->ElementsL(dicts, KDictionary);

                TInt count2 = dicts.Count();

                for (TInt j =0; j < count2; j++)

                {

                    CSenElement* dictEle = dicts[j];

                    if(dictEle)

                    {

                       CreateMSZlibL(name,dictEle);

                    }

                }

                CleanupStack::PopAndDestroy(); //dicts

             }

        }

    }

//4..start putting dictionaries in xml file

 //5.. now use http to get all invalid dictionaries from iDictionaries

    TInt count(iDictionaires.Count());

    TPtrC8 finalUri(KHttp);

    if(finalUri != KNullDesC8)

        {

        TRAP(error, GetHttpDictionaryL(finalUri, iHndlrCtx));

        }

    else 

        {

        error = KErrPathNotFound;

        }

//6..write iDictionaries to xml file

    SaveConfigurationL();

    iDictionaires.ResetAndDestroy(); //we dont need it any more

    return error;

    }

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

// TInt CWSStarDictionary::SaveL

// Saves a dictionary to a file

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

//

TInt CWSStarDictionary::SaveL(TFileName aFileName, const TDesC8& aContents)

{

    if (aFileName.Length() < 1 || aContents.Length() < 1)

        return KErrArgument;

    RFs fss;

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

    CleanupClosePushL(fss);

    TInt size = aContents.Length();

    TInt retVal(SysUtil::FFSSpaceBelowCriticalLevelL(&fss, size));

    if(retVal == KErrNone)

        {

        TLSLOG_L(KSenCoreServiceManagerLogChannelBase  , KMinLogLevel,"File system check: OK, there is enough space available.");

        }

    else

        {

        TLSLOG_L(KSenCoreServiceManagerLogChannelBase  , KMinLogLevel,"File system check: FAILED, NOT enough space available.");

        CleanupStack::PopAndDestroy(); //fss

        User::Leave(retVal);

        }

        RFile  dictFile;

        CleanupClosePushL(dictFile);

        retVal = dictFile.Replace(fss , aFileName, EFileWrite );

        if(retVal == KErrNone)

            {

            retVal = dictFile.Write(aContents);        

            }

       CleanupStack::PopAndDestroy(2); //fss, dictFile

       return retVal;

}

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

// CWSStarDictionary::SaveFileL

// Saves a dictionary to a file

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

//

void CWSStarDictionary::SaveFileL(const TDesC8& aUri, const TDesC8& aContents)

{

    TFileName filepath(iSavePath->Des());

    TInt loc = aUri.LocateReverse('/');

    if(loc != KErrNotFound)

    {

        TPtrC8 name = aUri.Right(aUri.Length() - loc - 1);

        HBufC* nameBuf = HBufC::NewLC(name.Length());

        TPtr nameBufPtr(nameBuf->Des());

        TInt ret = CnvUtfConverter::ConvertToUnicodeFromUtf8(nameBufPtr, name);        

        if(ret == KErrNone)

        {

            TFileName filename; 

            filename.Append(nameBufPtr);

            filepath.Append(filename);

            ret = SaveL(filepath, aContents);

        }

        CleanupStack::PopAndDestroy(nameBuf);

    }

}

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

// TInt CWSStarDictionary::GetHttpDictionaryL

//Method to download the dictionaries by HTTP

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

//

TInt CWSStarDictionary::GetHttpDictionaryL( const TDesC8& aEndpoint, MSenHandlerContext* aHndlrCtx )

    {

    if( !aHndlrCtx )

        {

        return KErrArgument;

        }    

//find the service description from handlercontext i.e. STS service        

    TPtrC8 contract(KWSStarSTSContract);

    RPointerArray<CSenWSDescription> serviceDescriptions;

    CleanupClosePushL(serviceDescriptions);

    TInt retVal(KErrNone);

    TInt leaveCode(KErrNone);

    TRAP(leaveCode, retVal = aHndlrCtx->GetSenCoreServiceManager()->ServiceDescriptionsL(serviceDescriptions, contract));

    CSenWSDescription* pSD = NULL;   

    if(leaveCode == KErrNone && retVal == KErrNone && serviceDescriptions.Count() > 0)

        {

        TUint32 iap(0);

        for(TInt j = 0; j < serviceDescriptions.Count(); j++)

            {

            pSD = serviceDescriptions[j];

            if( pSD )

                {

                TInt getIapRetCode = pSD->IapId(iap);    

                if( getIapRetCode == KErrNone )

                    {

                    pSD = serviceDescriptions[j]; // value IAP property over others (temp solution)

                    break;

                    }

                }

            }

        }

    CleanupStack::PopAndDestroy( );  // serviceDescriptions.Close()

    CSenWSDescription* pInitializer = CSenWSDescription::NewLC();

    pInitializer->SetEndPointL(aEndpoint);

    CWSStarHttpClient* pHttpClient = CWSStarHttpClient::NewLC(*(CSIF*)aHndlrCtx->GetAnyL(HandlerContextKey::KSIF()), pInitializer, *Log()); //*(CSIF*)iSenHandlerContext.GetAny(HandlerContextKey::KSIF()), pInitializer, *Log());//codescannerwarnings

    // Fix the first URI and request part of the request

    TInt count( iDictionaires.Count() );

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

        {

        CZlibDictionary* tempDict = iDictionaires[i];   

        if(!tempDict->Verified())

            {

            TPtrC8 endpoint(tempDict->DictUri());        

            TPtrC8 request(endpoint.Right(endpoint.Length() - aEndpoint.Length()));        

            HBufC8* pResponse = NULL;

            TInt leaveCode(KErrNone);

            TInt submitRetCode(KErrNone);

            TRAP( leaveCode, submitRetCode = pHttpClient->GetHttpL( request, pResponse, pSD ); )

            pHttpClient->DataTrafficDetails(iDictDetails);

            if( submitRetCode && retVal == KErrNone )

                {

                // Store the error code from the 1st failing request 

                retVal = submitRetCode;

                }    

            if( leaveCode && retVal == KErrNone )

                {

                retVal = leaveCode;

                }    

            if(pResponse && pResponse->Length() > 0)

                {

                CleanupStack::PushL(pResponse);            

                TPtrC8 resPtr(pResponse->Des());

                if(tempDict->SetDictContentsL(resPtr) == KErrNone)

                {

                    SaveFileL(endpoint, resPtr);

                }

                CleanupStack::PopAndDestroy();

                }    

            else // if(retVal == 404)    

                {

                delete pResponse;

                }

            }

        } // for each request

    CleanupStack::PopAndDestroy(pHttpClient); 

    CleanupStack::PopAndDestroy(pInitializer);  

    return retVal;

}

TInt CWSStarDictionary::LoadDictionariesL()

{

    TFileName dictXml(iSavePath->Des());

    dictXml.Append(KDictionaryFile);

    CDictXml* dict= CDictXml::NewL();

    CleanupStack::PushL(dict);

    TInt fileError = dict->ReadFileL(dictXml);

    if(fileError == KErrNone)

    {

        CSenElement* dictEle = dict->XMLDocL();

        if(dictEle)

        {

            LoadDictionariesL(dictEle);

        }

    }

    CleanupStack::PopAndDestroy(dict);

    return fileError;    

}

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

// void CWSStarDictionary::LoadFileL

// This method Loads the dictionaries from the files present in private folder.

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

//