/*

* Copyright (c) 2009 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 <emulator.h>

#include <uri16.h>

#include <apmrec.h>

#include <apgcli.h>

#include "ResourceHandle.h"

#include "W32FileConnection.h"

#include "W32FileReader.h"

#include "ResourceHandleManagerSymbian.h"

#include "StaticObjectsContainer.h"

#include "ResourceRequest.h"

#include <BrCtlSpecialLoadObserver.h>

#include "brctl.h"

#include "DeprecatedString.h"

HANDLE   iFh;

const TInt KFileReadChunkSize = 23920; // bytes

_LIT8( KResLoaderLatin1, "iso-8859-1" );

_LIT8( KResLoaderUCS2, "iso-10646-ucs-2" );

_LIT8( KResLoaderWapWmlc, "application/vnd.wap.wmlc" );

static int s_fileTransactionsCount = 0;

using namespace WebCore;

CW32FileConnection::CW32FileConnection(ResourceHandle* _handle) : MUrlConnection(_handle)

{

    m_fileName = 0;

    m_fileReader = 0;

    s_fileTransactionsCount++;

    m_chunkIndex = 0;

    m_charset = 0;

    m_contentType = 0;

}

CW32FileConnection::~CW32FileConnection()

{

    ::CloseHandle(iFh);

    s_fileTransactionsCount--;

    delete m_fileName;

    delete m_fileReader;

    delete m_charset;

    delete m_contentType;

//    m_file.Close();

}

TInt CW32FileConnection::submit()

{

    TRAPD(error, submitL());

    return error;

}

//========================================================================

//  CW32FileConnection::submitL

//========================================================================

TInt CW32FileConnection::submitL()

{

    TInt error(KErrNone);

    TPtrC8 urlPtr( m_handle->request().url().des() );

    m_fileName = parseFileNameL( urlPtr );

    if (m_fileName) {

    iFh = Emulator::CreateFile(m_fileName->Des().PtrZ(), GENERIC_READ,

                           FILE_SHARE_WRITE, NULL, OPEN_EXISTING, 0, NULL);

    if (iFh == INVALID_HANDLE_VALUE) {

      error = Emulator::LastError();

    }

    else {

        TUint32  fileSize = ::GetFileSize(iFh, NULL); //W32 call

        m_maxSize = fileSize;

    if (m_fileReader == NULL) {

        m_fileReader = CW32FileReader::NewL(iFh, KFileReadChunkSize, this);

        }

    m_fileReader->StartReading();

    }

  }

  else {

    error = KErrArgument;

  }

    User::LeaveIfError(error);

}

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

// CW32FileConnection::parseFileNameL

// Translate the file name from a URL to a valid file name in the system.

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

//

HBufC* CW32FileConnection::parseFileNameL(const TDesC8& aUrl )

{

    //To convert TPtrC8 to Tptr16

	TBufC8<200> Urlbuf(aUrl);

    HBufC16* buf16 = HBufC16::NewL(256);//delete buf16 dont forget.

    TPtr16 bufptr16(buf16->Des());

    bufptr16.Copy(Urlbuf.Des());

    TInt status;

    TUriParser parser;

    HBufC* fileName = NULL;

    status = parser.Parse( bufptr16 );

    if( status == KErrNone ) {

        // this must be the drive letter

        TPtrC host = parser.Extract( EUriHost );

        TPtrC path = parser.Extract( EUriPath );

        // add missing ":"

        fileName = HBufC::NewL( (host.Length()?host.Length()+1:0) + path.Length()+ 1/*0 terminated*/ );

        TPtr fileNamePtr( fileName->Des() );

        if( host.Length() == 1 ) {

            // fix c to c:

            fileNamePtr.Copy( host );

            fileNamePtr.Append( _L(":") );

        }

        else {

            // according to symbian uri parser in case of

            // file:///c:\foo.html

            // host: /c:\foo.html

            // path: /c:\foo.html

            // remove: / from the begenning of the path

            if( path.Length() > 2 && path[0] == '/' && path[2] == ':' ) {

                // move pointer from "/c:\" to "c:\"

                path.Set( path.Mid( 1 ) );

            }

        }

        fileNamePtr.Append( path );

        // fix slashes

        for( TInt i = 0; i < fileNamePtr.Length(); i++ ) {

            if( fileNamePtr[ i ] == '/' ) {

                fileNamePtr[ i ] = '\\';

            }

        }

    // then replace possible %20-sequences with blank

    TInt pos = 0;

    _LIT(KWinSP, "%20");

    _LIT(KSpace, " ");

    TInt len = (&KWinSP)->Length();

    while ((pos = fileNamePtr.FindC(KWinSP)) != KErrNotFound) {

        fileNamePtr.Replace(pos, (&KWinSP)->Length(), KSpace);

    }

//    return fileName16;

//    CleanupStack::PushL( fileName16 );

      delete buf16;

      return fileName;

}

}

void CW32FileConnection::cancel()

{

    if( m_fileReader ) {

        m_fileReader->StopReading();

    }

}

void CW32FileConnection::download(WebCore::ResourceHandle* handle,

                              const WebCore::ResourceRequest& request,

                              const WebCore::ResourceResponse& response)

{

    // stop reading and close the file

    m_fileReader->StopReading();

    m_cancelled = true;

    ::CloseHandle(iFh); //windows call

    // send data to the host application

    MBrCtlSpecialLoadObserver* loadObserver = StaticObjectsContainer::instance()->brctl()->brCtlSpecialLoadObserver();

    if(loadObserver) {

        RArray<TUint> typeArray;

        CDesCArrayFlat* desArray = new (ELeave) CDesCArrayFlat(4);

        CleanupStack::PushL(desArray);

        //

        HBufC* url = HBufC::NewLC(handle->request().url().url().length());

        url->Des().Copy(handle->request().url().des());

        typeArray.Append(EParamRequestUrl);

        desArray->AppendL(*url);

        typeArray.Append(EParamCharset);

        desArray->AppendL(*m_charset);

        typeArray.Append(EParamReceivedContentType);

        desArray->AppendL(*m_contentType);

        typeArray.Append(EParamLocalFileName);

        desArray->AppendL(*m_fileName);

        //

        loadObserver->HandleDownloadL(&typeArray, desArray);

        //

        typeArray.Close();

        desArray->Reset();

        CleanupStack::PopAndDestroy(2); // desArray, url 

    }

}

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

// CW32FileConnection::contentTypeL

// Determine the content type of the file.

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

HBufC8* CW32FileConnection::contentTypeL()

{

    TPtrC8 contentTypePtr;

    HBufC8* contentType = NULL;

    TDataRecognitionResult dataType;

    RApaLsSession apaSession;

    TInt ret;

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

    // Ask the application architecture to find the file type

    TPtrC8 chunkPtr;

    m_fileReader->GetChunkBuffer( chunkPtr );

    ret = apaSession.RecognizeData( m_fileName->Des(), chunkPtr, dataType );

    apaSession.Close();

    if( ret == KErrNone &&

        ( dataType.iConfidence == CApaDataRecognizerType::ECertain ) ||

        ( dataType.iConfidence == CApaDataRecognizerType::EProbable ) ) {

        // If the file type was found, try to match it to a known file type

        contentTypePtr.Set( dataType.iDataType.Des8() );

    }

    else {

        // extensions

        _LIT( KCssExt, ".css" );

        _LIT(KWbmpExt, ".wbmp");

        _LIT(KEcmaScriptExt, ".es");

        _LIT(KJavaScriptExt, ".js");

        TPtrC extPtr( m_fileName->Right( m_fileName->Length() -  m_fileName->LocateReverse('.') ) );

        if( extPtr.CompareF( KCssExt() ) == 0 ) {

            contentTypePtr.Set( _L8( "text/css" ) );

        }

        else if( extPtr.CompareF( KWbmpExt() ) == 0 ) {

            contentTypePtr.Set( _L8( "image/vnd.wap.wbmp" ) );

        }

        else if( extPtr.CompareF( KEcmaScriptExt() ) == 0 ||

            extPtr.CompareF( KJavaScriptExt() ) == 0 ) {

            contentTypePtr.Set( _L8( "text/ecmascript" ) );

        }

    }

    if( contentTypePtr.Length() ) {

        contentType = HBufC8::NewL( contentTypePtr.Length() );

        contentType->Des().Copy( contentTypePtr );

    }

    return contentType;

}

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

// CW32FileConnection::contentEncoding

// Determine the content encoding of the file.

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

//

TPtrC8 CW32FileConnection::contentEncoding(const TDesC8& aContentTypeString ) const

{

    // Assume Latin-1 for xhtml and html. ucs2 for any other

    TPtrC8 charset( KResLoaderLatin1 );

    TPtrC8 httpAppString( KResLoaderWapWmlc );

    TPtrC8 contentString( aContentTypeString );

    // Is the contentType a HTTP_application_vnd_wap_wmlc_string

    TUint index = contentString.FindF( httpAppString );

    if( index == 0 ) {

        // This is a HTTP_application_vnd_wap_wmlc_string

        charset.Set( KResLoaderUCS2 );

    }

    return charset;

}

void CW32FileConnection::response()

{

    TRAPD(error, responseL());

    if (error) {

        complete(error);

    }        

}

void CW32FileConnection::responseL()

{

    if (m_chunkIndex == 0 ) {

        HBufC8* contentType = contentTypeL();

        if( contentType ) {

            m_contentType = HBufC::NewL(contentType->Length());

            m_contentType->Des().Copy(*contentType);

            TPtrC8 contentEncodingPtr( contentEncoding( contentType->Des() ) );

            ResourceResponse response(m_handle->request().url().des(), contentType->Des(), m_maxSize, contentEncodingPtr, String() );

            const TDesC& charset = response.textEncodingName().des();

            m_charset = charset.AllocL();

            response.setHTTPStatusCode(200);

            CResourceHandleManager::self()->receivedResponse(m_handle, response, this);

        }

    }

    // If it is not Browser content, reading the file is canceled in CW32FileConnection::download().

    if (!m_cancelled) {

        TPtrC8 chunkPtr;

        m_fileReader->GetChunkBuffer( chunkPtr );    

        m_chunkIndex++;

        CResourceHandleManager::self()->receivedData(m_handle, chunkPtr, m_maxSize, this);

    }

}

void CW32FileConnection::complete(int error)

{

    CResourceHandleManager::self()->receivedFinished(m_handle, error, this);

    derefHandle();

}

// end of file