/*
* Copyright (c) 2008-2008 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:  Tracks data transmitted through a network connection.
*
*/

#include <httpstringconstants.h>
#include <mhttpdatasupplier.h>
#include <rhttpheaders.h>
#include "irdebug.h"

#include "irdatatransfertracker.h"

// The threshold in bytes after which notifications are sent to observers.
const TInt KIRDataTransferTrackerThreshold = 104858;	// 0.1  MB = 104857.6 bytes (rounded)
const TInt KIRDataTransferTrackerMiniThreshold = 1049;	// 0.01 MB = 1048.57 bytes (rounded)

// The overhead in bytes per one HTTP header.
const TInt KVRBytesPerHeaderOverhead = 2; // "\r\n"
// The overhead in bytes per one header field in a request.
const TInt KVRBytesPerHeaderFieldOverhead = 4; // ": \r\n"
// The overhead in bytes per one header sent.
const TInt KVRBytesPerHeaderSentOverhead = 4; // "  \r\n"
// The overhead in bytes per one header received.
const TInt KVRBytesPerHeaderReceivedOverhead = 3; // " \r\n"

// ---------------------------------------------------------------------------
// Two-phased constructor.
// ---------------------------------------------------------------------------
//
CIRDataTransferTracker* CIRDataTransferTracker::NewL()
    {
	IRLOG_DEBUG( "CIRDataTransferTracker::NewL - Entering");
    CIRDataTransferTracker* self = new ( ELeave ) CIRDataTransferTracker;
    CleanupStack::PushL( self );
    self->ConstructL();
    CleanupStack::Pop( self );
	IRLOG_DEBUG( "CIRDataTransferTracker::NewL - Exiting");
    return self;
    }

// ---------------------------------------------------------------------------
// Constructor.
// ---------------------------------------------------------------------------
//
CIRDataTransferTracker::CIRDataTransferTracker()
    {
	IRLOG_DEBUG( "CIRDataTransferTracker::CIRDataTransferTracker - Entering");
	bThresholdCrossed = EFalse;
	IRLOG_DEBUG( "CIRDataTransferTracker::CIRDataTransferTracker - Exiting");
    }

// ---------------------------------------------------------------------------
// Second-phase constructor.
// ---------------------------------------------------------------------------
//
void CIRDataTransferTracker::ConstructL() const
    {
    IRLOG_DEBUG( "CIRDataTransferTracker::ConstructL");
	return;
    }

// ---------------------------------------------------------------------------
// Destructor.
// ---------------------------------------------------------------------------
//
CIRDataTransferTracker::~CIRDataTransferTracker()
    {
    	IRLOG_DEBUG( "CIRDataTransferTracker::~CIRDataTransferTracker - Entering");
    	iObserver = NULL;
        IRLOG_DEBUG( "CIRDataTransferTracker::~CIRDataTransferTracker - Exiting");

    }

// ---------------------------------------------------------------------------
// From class MIRDataTransferTracker.
// Sets the observer.
// ---------------------------------------------------------------------------
//
void CIRDataTransferTracker::SetObserver( MIRDataTransferObserver* aObserver )
    {
    IRLOG_DEBUG( "CIRDataTransferTracker::SetObserver - Entering");
    iObserver = aObserver;
    IRLOG_DEBUG( "CIRDataTransferTracker::SetObserver - Exiting");
    }

// ---------------------------------------------------------------------------
// From class MIRDataTransferTracker.
// Returns the current transferred data amounts.
// ---------------------------------------------------------------------------
//
const MIRDataTransferTracker::TIRDataTransferPckg& CIRDataTransferTracker::TransferredData() const
    {
    IRLOG_DEBUG( "CIRDataTransferTracker::TIRDataTransferPckg");
    return iPckg;
    }

// ---------------------------------------------------------------------------
// From class MIRDataTransferTracker.
// Binds this to track the supplied HTTP session.
// ---------------------------------------------------------------------------
//
void CIRDataTransferTracker::BindL( RHTTPSession aSession, TIRTransferCategory aCategory )
    {
    IRLOG_DEBUG2( "CIRDataTransferTracker::BindL() - aCategory = %d", static_cast<TInt>( aCategory ) );

    aSession.ConnectionInfo().SetPropertyL(
        aSession.StringPool().StringF( HTTP::ESessionId, aSession.GetTable() ), 
        	THTTPHdrVal( aCategory ) );
    aSession.FilterCollection().AddFilterL(
        *this, THTTPEvent::EAnyTransactionEvent, MHTTPFilter::EClientFilters, RStringF() );
    IRLOG_DEBUG( "CIRDataTransferTracker::BindL - Exiting");
    }

// ---------------------------------------------------------------------------
// From class MIRDataTransferTracker.
// Handles raw data transfers.
// ---------------------------------------------------------------------------
//
void CIRDataTransferTracker::RawDataTransferredL( TInt aBytesSent, TInt aBytesReceived, 
												  TIRTransferCategory aCategory )
    {
    IRLOG_DEBUG( "CIRDataTransferTracker::RawDataTransferredL - Entering");
    ProcessDataL( aBytesSent, aBytesReceived, aCategory );
    IRLOG_DEBUG( "CIRDataTransferTracker::RawDataTransferredL - Exiting");
    }

// ---------------------------------------------------------------------------
// From class MHTTPFilter.
// Invoked when HTTP transactions are sent or received.
// ---------------------------------------------------------------------------
//
void CIRDataTransferTracker::MHFRunL(const RHTTPTransaction aTransaction, const THTTPEvent& aEvent)
    {
    IRLOG_DEBUG2( "CIRDataTransferTracker::MHFRunL() - aEvent.iStatus = %d", aEvent.iStatus );

    RHTTPSession session = aTransaction.Session();

    THTTPHdrVal categoryVal;

    if( session.ConnectionInfo().Property(
        session.StringPool().StringF( HTTP::ESessionId, session.GetTable() ), categoryVal ) )
        {
        TIRTransferCategory category = static_cast<TIRTransferCategory>( categoryVal.Int() );

        switch ( aEvent.iStatus )
            {
            case THTTPEvent::EGotResponseHeaders:
                ParseHeaderSizeL( aTransaction, category );
                break;
            case THTTPEvent::EGotResponseBodyData:
                ParseBodySizeL( aTransaction, category );
                break;
            default:
                break;
            }
        }
    IRLOG_DEBUG( "CIRDataTransferTracker::MHFRunL - Exiting");
    }

// ---------------------------------------------------------------------------
// Calculates the header field sizes in bytes from the specified headers.
// ---------------------------------------------------------------------------
//
TInt CIRDataTransferTracker::HeaderSize( const RHTTPTransaction aTransaction, 
										 RHTTPHeaders aHeaders )
    {
    IRLOG_DEBUG( "CIRDataTransferTracker::HeaderSize - Entering");
    TInt size = KVRBytesPerHeaderOverhead;

    RStringPool stringPool = aTransaction.Session().StringPool();

    THTTPHdrFieldIter it = aHeaders.Fields();
    it.First();

    while ( !it.AtEnd() )
        {
        RStringF key = stringPool.StringF( it() );

        TPtrC8 ptr;
        aHeaders.GetRawField( key, ptr );

        size += key.DesC().Size();
        size += ptr.Size();
        size += KVRBytesPerHeaderFieldOverhead;

        ++it;
        }
    IRLOG_DEBUG( "CIRDataTransferTracker::HeaderSize - Exiting");
    return size;

    }

// ---------------------------------------------------------------------------
// Parses the header sizes (both request and response) of the supplied HTTP
// transaction, logging it under the specified category.
// ---------------------------------------------------------------------------
//
void CIRDataTransferTracker::ParseHeaderSizeL( const RHTTPTransaction aTransaction, 
								   			   TIRTransferCategory aCategory )
    {
    IRLOG_DEBUG2( "CIRDataTransferTracker::ParseHeaderSizeL() - aCategory = %d", static_cast<TInt>( aCategory ) );

    RHTTPSession session = aTransaction.Session();

    // Parse the request size first.

    RHTTPRequest request = aTransaction.Request();
    TInt sent = HeaderSize( aTransaction, request.GetHeaderCollection() );

    // Now that the actual header fields are parsed we have to manually extract the original request.
    // The format of the request is "%S %S %S\r\n", where the first string is the method (GET or POST),
    // the second is the full URI of the request, and the third the HTTP protocol version in use.

    RStringF http = session.StringPool().StringF( HTTP::EHttp11, session.GetTable() );

    sent += request.Method().DesC().Size();
    sent += request.URI().UriDes().Size();
    sent += http.DesC().Size();
    sent += KVRBytesPerHeaderSentOverhead;

    // Proceed to parse the response size.

    RHTTPResponse response = aTransaction.Response();
    TInt received = HeaderSize( aTransaction, response.GetHeaderCollection() );

    // Now that the actual header fields of the response are parsed, we have to manually extract the
    // original response. The format of the response is "%S %d %S\r\n", where the first string is the HTTP
    // protocol version, the first integer is the HTTP status code, and the second string is the
    // status text.

    TBuf8<KDefaultRealWidth> responseCode;
    responseCode.AppendNum( static_cast<TInt64>( response.StatusCode() ) );

    received += session.StringPool().StringF( HTTP::EHttp11, session.GetTable() ).DesC().Size();
    received += responseCode.Size(); // Contains the byte for the trailing space as is, so need not add it as overhead below.
    received += response.StatusText().DesC().Size();
    received += KVRBytesPerHeaderReceivedOverhead;

    ProcessDataL( sent, received, aCategory );
    IRLOG_DEBUG( "CIRDataTransferTracker::ParseHeaderSizeL - Exiting");

    }

// ---------------------------------------------------------------------------
// Parses the body size of the supplied HTTP transaction, logging it under the specified category.
// ---------------------------------------------------------------------------
//
void CIRDataTransferTracker::ParseBodySizeL(const RHTTPTransaction aTransaction, 
											TIRTransferCategory aCategory )
    {
    IRLOG_DEBUG2( "CIRDataTransferTracker::ParseBodySizeL() - aCategory = %d", static_cast<TInt>(aCategory) );

    ASSERT( aTransaction.Response().HasBody() );

    TPtrC8 ptr;
    aTransaction.Response().Body()->GetNextDataPart( ptr );

    ProcessDataL( 0, ptr.Size(), aCategory );
    IRLOG_DEBUG( "CIRDataTransferTracker::ParseBodySizeL - Exiting");
    }

// ---------------------------------------------------------------------------
// Processes raw data sent and/or received via the connection.
// ---------------------------------------------------------------------------
//
void CIRDataTransferTracker::ProcessDataL( TInt aBytesSent, TInt aBytesReceived, 
										   TIRTransferCategory aCategory )
    {
    IRLOG_DEBUG4( "CIRDataTransferTracker::ProcessDataL() - aBytesSent = %d, aBytesReceived = %d, aCategory = %d",
        aBytesSent, aBytesReceived, static_cast<TInt>(aCategory) );

    switch ( aCategory )
        {
        case MIRDataTransferTracker::EIRTransferCategoryIsds:
            iPckg.iBytesSentIsds += aBytesSent;
            iPckg.iBytesReceivedIsds += aBytesReceived;
            break;
        case MIRDataTransferTracker::EIRTransferCategoryAudio:
            iPckg.iBytesSentAudio += aBytesSent;
            iPckg.iBytesReceivedAudio += aBytesReceived;
            break;
        default:
            iPckg.iBytesSentUnknown += aBytesSent;
            iPckg.iBytesReceivedUnknown += aBytesReceived;
            break;
        }

    iPckg.iBytesSentTotal += aBytesSent;
    iPckg.iBytesReceivedTotal += aBytesReceived;

    iBytesSinceLastNotification += aBytesSent + aBytesReceived;

    DispatchNotificationL();
    IRLOG_DEBUG( "CIRDataTransferTracker::ProcessDataL() - Exiting");
    }

// ---------------------------------------------------------------------------
// Dispatches the notification of the data transfer conditionally.
// ---------------------------------------------------------------------------
//
void CIRDataTransferTracker::DispatchNotificationL()
    {
    IRLOG_DEBUG2( "CIRDataTransferTracker::DispatchNotificationL() - iBytesSinceLastNotif = %d",
        iBytesSinceLastNotification );

	// Set flag when Byte Counter crosses first threshold 0.1 MB
	if( bThresholdCrossed == EFalse && 
		(iPckg.iBytesSentTotal+iPckg.iBytesReceivedTotal) >= KIRDataTransferTrackerThreshold )
		bThresholdCrossed = ETrue;

	// Smooth updates to each 0.01 MB
	if( /*bThresholdCrossed == EFalse &&*/ iBytesSinceLastNotification >= KIRDataTransferTrackerMiniThreshold)
        {
        if ( iObserver )
            {
            iObserver->HandleDataTransferEventL( iPckg );
            }
        iBytesSinceLastNotification = 0;
        }


	// Streaming updates to each 0.1 MB afterwards
    else if ( iBytesSinceLastNotification >= KIRDataTransferTrackerThreshold )
        {
        if ( iObserver )
            {
            iObserver->HandleDataTransferEventL( iPckg );
            }
        iBytesSinceLastNotification = 0;
        }
    IRLOG_DEBUG( "CIRDataTransferTracker::DispatchNotificationL() - Exiting");

    }