/*
* Copyright (c) 2006-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: CSocketsRead is an active obejct that reads data from
* an already open socket and calculates some metrics from the data read
*
*/

// INCLUDE FILES
#include "SocketsRead.h"
#include "SocketsEngine.h"
#include "uinotify.h"
#include "Utils.h"


// ---------------------------------------------------------
// CSocketsRead::NewL(MUINotify& aConsole, RSocket& aSocket)
// EPOC two phased constructor
// ---------------------------------------------------------
//
CSocketsRead* CSocketsRead::NewL(MUINotify& aConsole, RSocket& aSocket, CSocketsEngine& aEngine)
{
    CSocketsRead* self = CSocketsRead::NewLC(aConsole, aSocket, aEngine);
    CleanupStack::Pop(self);
    return self;
}

// ---------------------------------------------------------
// CSocketsRead::NewLC(MUINotify& aConsole, RSocket& aSocket)
// EPOC two phased constructor
// ---------------------------------------------------------
//
CSocketsRead* CSocketsRead::NewLC(MUINotify& aConsole, RSocket& aSocket, CSocketsEngine& aEngine)
{
    CSocketsRead* self = new (ELeave) CSocketsRead(aConsole, aSocket, aEngine);
    CleanupStack::PushL(self);
    self->ConstructL();
    return self;
}

// ---------------------------------------------------------
// CSocketsRead::CSocketsRead(MUINotify& aConsole, RSocket& aSocket)
// Constructor
// ---------------------------------------------------------
//
CSocketsRead::CSocketsRead(MUINotify& aConsole, RSocket& aSocket, CSocketsEngine& aEngine)
: CActive(/*EPriorityStandard*/EPriorityHigh),
iEngine(aEngine),
iSocket(aSocket),
iConsole(aConsole)
{
}

// ---------------------------------------------------------
// CSocketsRead::~CSocketsRead()
// Destructor
// ---------------------------------------------------------
//
CSocketsRead::~CSocketsRead()
{
    Cancel();
}

// ---------------------------------------------------------
// CSocketsRead::ConstructL()
// EPOC two-phased constructor
// ---------------------------------------------------------
//
void CSocketsRead::ConstructL()
{
    CActiveScheduler::Add(this);
}


// ---------------------------------------------------------
// CSocketsRead::Start(TInetAddr* aAddress, TUint aProtocol)
// Initiate a read from socket.
// ---------------------------------------------------------
//
void CSocketsRead::Start(TInetAddr* aAddress, TUint aProtocol)
{
    iAddress = aAddress;
    iProtocol = aProtocol;

    // Initiate a new read from socket into iBuffer
    if (!IsActive())
    {
        IssueRead();
    }
}

// ---------------------------------------------------------
// CSocketsRead::StartRAWRead()
// Start RAW read
// ---------------------------------------------------------
//

void CSocketsRead::StartRAWRead(TInetAddr* aAddress, TUint aProtocol)
	{
    iAddress = aAddress;
    iProtocol = aProtocol;
    iBodySize = 0; // REMEMBER TO DO THIS, OR OTHERWISE WE THINK THIS IS HTTP TRAFFIC
    iDoPerformance = ETrue;
	iUdpPacketCounter = 0;
	
    // Initiate a new read from socket into iBuffer
    iConsole.PrintNotify(_L("Getting data...\n"));
    iDoCount = ETrue;
    iStartTime.UniversalTime();
    iReceivedBytes = 0;
    
    if (!IsActive())
    {
        IssueRead();
	}
}


// ---------------------------------------------------------
// CSocketsRead::IssueRead()
// Receive data.
// ---------------------------------------------------------
//
void CSocketsRead::IssueRead()
{
    // Initiate a new read from socket into iBuffer
    ASSERT(!IsActive());
    
    switch(iProtocol)
    {
    case KProtocolInetTcp:
        iSocket.RecvOneOrMore(iBuffer, 0, iStatus, iDummyLength);
        break;
    case KProtocolInetUdp:
    	iBuffer.Zero();
        iSocket.RecvFrom(iBuffer, *iAddress, 0, iStatus/*, iDummyLength*/);
        break;
    }    
    SetActive();
}


// ---------------------------------------------------------
// CSocketsRead::SetPerformance(const TBool aValue)
// Set performance calculation on/off
// ---------------------------------------------------------
//
void CSocketsRead::SetPerformance(const TBool aValue)
{
    iDoPerformance = aValue;
    iReceivedBytes = 0;
    iDoCount = EFalse;
    
    //TInt recBuf;
    //iSocket.SetOpt(KSORecvBuf, KSOLSocket, 200000);
    //iSocket.GetOpt(KSORecvBuf, KSOLSocket, recBuf);
}


// ---------------------------------------------------------
// CSocketsRead::RunL()
// Called when request has completed.
// ---------------------------------------------------------
//
void CSocketsRead::RunL()
    {
    // Active object request complete handler
    if (iStatus == KErrNone)
        {
        // Character has been read from socket
        if(iDoPerformance)
            {
            if(!iDoCount)
                {
                iHeaders.Append(iBuffer.Left(iHeaders.MaxLength() - iHeaders.Length()));
                iHeaders.LowerCase();

                TInt end = iHeaders.Find(_L8("\r\n\r\n"));
                TInt emptyLine = iBuffer.Find(_L8("\r\n\r\n"));

                if(!(end == KErrNotFound))
                    {
                    TInt cl = iHeaders.Find(_L8("content-length:"));

                    if(!(cl == KErrNotFound))
                        {
                        TBuf8<512> temp;
                        temp = iHeaders.Mid(cl, end - cl);

                        TInt st = temp.Locate(':');
                        TInt endcl = temp.Find(_L8("\r\n"));

                        if ( endcl != KErrNotFound )
                            {
                            // not the last line in headers.
                            temp = temp.Mid(st+1, endcl - st);                            
                            }
                        else
                            {
                            temp = temp.Mid(st+1);                            
                            }
                        
                        temp.Trim();

                        TLex8 lex(temp);
                        TInt err = lex.Val(iBodySize);

                        if(err == KErrNone)
                            {
                            iConsole.PrintNotify(_L("Getting body...\n"));
                            iDoCount = ETrue;
                            iStartTime.UniversalTime();
                            iReceivedBytes = iBuffer.Length() - emptyLine - 4; 
                            }
                        }
                    }
                }
            else
                {          
                iReceivedBytes += iBuffer.Length();
                if (iProtocol == KProtocolInetUdp)
                    {
                    if (iUdpPacketCounter == 0)
                        iStartTime.UniversalTime(); // Start time calculation from the first received packet.
                    iUdpPacketCounter++;
                    if (iUdpPacketCounter == KMaximumPacketCount)
                        {
                        TBuf8<128> b(_L8("Got data\n"));
                        TInt ploss = CalculatePacketLoss();
                        Utils::CalculateThroughput(b, iStartTime, iReceivedBytes);
                        iEngine.Disconnect();
                        b.AppendFormat(_L8("Ploss: %d %%\n"),ploss);
                        iConsole.PrintNotify(b);
                        return; // do not issue any request.
                        }
                    else if (iUdpPacketCounter > KMaximumPacketCount)
                        {
                        iConsole.PrintNotify(_L8("Unexpected state\n"));
                        iEngine.Disconnect();
                        iSocket.Close();
                        return;
                        }

                    }
                }

            // Check if all the data has been received
            if(iReceivedBytes == iBodySize)
                {
                // Throughput calculation
                TBuf8<128> b(_L8("Got body\n"));
                Utils::CalculateThroughput(b, iStartTime, iReceivedBytes);
                iConsole.PrintNotify(b);
                iHeaders.Zero();
                iDoCount = EFalse;
                }
            }
        else
            {            
            iConsole.PrintNotify(iBuffer);
            }

        IssueRead(); // Immediately start another read
        }
    else
        {
        if( iStatus.Int() == KErrEof || 
                iStatus.Int() == KErrDisconnected || 
                iStatus.Int() == KErrCancel )
            {
            TBuf<64> text(_L("HTTP Get Completed"));
            iEngine.StopTickCount(text);
            // Remote server closed the socket
            if (iBodySize == 0) // We don't know how much we are expecting data so we calculate throughput here
                {
                iReceivedBytes += iBuffer.Length();
                // Throughput calculation
                TBuf8<128> b(_L8("Got body\n"));
                Utils::CalculateThroughput(b, iStartTime, iReceivedBytes);
                iConsole.PrintNotify(b);
                }
            TBuf<64> note;
            note.Format(_L("\nSocket closed: (%d)\n"), iStatus.Int());
            iEngine.Disconnect();
            iConsole.PrintNotify(note);
            }
        else if(iStatus.Int() == KErrTimedOut)
            {
            // LastSocketActivityTimeout has been elapsed
            TBuf<64> note;
            note.Copy(_L("\nLastSocketActivityTimeOut elapsed\n\n"));
            iEngine.Disconnect();
            iConsole.PrintNotify(note);
            }
        else
            {
            // Error: pass it up to user interface
            TBuf<50> err;
            err.Format(_L("\nCSocketsRead error %d\n"), iStatus.Int());
            iConsole.PrintNotify(err);
            }
        iSocket.Close();  // error is always fatal.      
        }	
    }

// ---------------------------------------------------------
// CSocketsRead::DoCancel()
// Cancel ongoing requests.
// ---------------------------------------------------------
//
void CSocketsRead::DoCancel()
{
    // Cancel asychronous read request
    iSocket.CancelRead();
    // If we were accepting raw UDP-traffic, we should stop and analyse.
    if (iBodySize == 0 && iProtocol == KProtocolInetUdp && iReceivedBytes != 0)
	{
        TBuf8<128> b(_L8("Got body\n"));
        Utils::CalculateThroughput(b, iStartTime, iReceivedBytes);
        iConsole.PrintNotify(b);
	}
}

// ---------------------------------------------------------
// CSocketsRead::CalculatePacketLoss()
// Calculates packet loss rate
// @return ploss percentage
// ---------------------------------------------------------
//
TInt32 CSocketsRead::CalculatePacketLoss()
{
	TUint32* seqNumberPointer = (TUint32*)(iBuffer.Ptr());
	TUint32 sequenceNumberOfThisPacket = ByteOrder::Swap32( *seqNumberPointer );
	if(sequenceNumberOfThisPacket != 0)
	    return (100 - (100 * iUdpPacketCounter) / sequenceNumberOfThisPacket);
	else return 100;
}

// EOF