/*
* Copyright (c) 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:  This is the implementation of application class
 *
*/


#include "datasegmenter.h"

CDataSegmenter* CDataSegmenter::NewL()
    {
    CDataSegmenter* self = NewLC();
    CleanupStack::Pop(self);
    return self;
    }

CDataSegmenter* CDataSegmenter::NewLC()
    {
    CDataSegmenter* self = new (ELeave) CDataSegmenter();
    CleanupStack::PushL(self);
    self->ConstructL();
    return self;
    }

CDataSegmenter::CDataSegmenter()
    {
    // No work to do
    }

CDataSegmenter::~CDataSegmenter()
    {
    delete iPayloadBuf;

    delete iPacket;
    }

void CDataSegmenter::SegmentDataL(const TDesC8& aInitialHeader,
        const TDesC8& aPayload, TChar aAdditionalHeaderByte, TInt aMTU)
    {
    // Store the continuation packet header byte and MTU
    iAdditionalHeaderByte = aAdditionalHeaderByte;
    iMTU = aMTU;

    // Determine the payload that will go in the first packet
    TInt initialPayLoadSize = Min((iMTU - aInitialHeader.Length()),
            aPayload.Length());

    // The initial packet size
    TInt initialSize = aInitialHeader.Length() + initialPayLoadSize;

    TPtr8 dataPtr(0, 0);
    if (!iPacket)
        {
        // Allocate the packet buffer, if it doesn't exist
        iPacket = HBufC8::NewL(initialSize);
        dataPtr.Set(iPacket->Des());
        }
    else
        {
        // Ensure the existing buffer is large enough to hold the new data
        dataPtr.Set(iPacket->Des());
        if (dataPtr.MaxLength() < initialSize)
            {
            delete iPacket;
            iPacket = 0;
            iPacket = HBufC8::NewL(initialSize);
            dataPtr.Set(iPacket->Des());
            }
        }

    // Reset the packet buffer
    dataPtr.Zero();
    // Append the header and initial payload
    dataPtr.Append(aInitialHeader);
    dataPtr.Append(aPayload.Mid(0, initialPayLoadSize));

    // Reset the payload pointer to NULL
    iPayloadBufPtr.Set(TPtrC8(0, 0));

    // Determine the remaining payload
    TInt payloadRemaining = aPayload.Length() - initialPayLoadSize;

    // If there is some remaining payload, store it
    if (payloadRemaining > 0)
        {
        if (!iPayloadBuf)
            {
            // Allocate the payload buffer, if it doesn't exist
            iPayloadBuf = HBufC8::NewL(payloadRemaining);
            dataPtr.Set(iPayloadBuf->Des());
            }
        else
            {
            // Ensure the existing buffer is large enough to hold the new data
            dataPtr.Set(iPayloadBuf->Des());
            if (dataPtr.MaxLength() < payloadRemaining)
                {
                delete iPayloadBuf;
                iPayloadBuf = 0;
                iPayloadBuf = HBufC8::NewL(payloadRemaining);
                dataPtr.Set(iPayloadBuf->Des());
                }
            }

        // Reset the payload buffer
        dataPtr.Zero();
        // Copy the remaining payload
        dataPtr.Append(aPayload.Mid(initialPayLoadSize));
        // Initialise the payload pointer
        iPayloadBufPtr.Set(iPayloadBuf->Des());
        }
    }

const HBufC8* CDataSegmenter::FirstPacketL() const
    {
    // Leave if no packet created.
    User::LeaveIfNull(iPacket);

    // Return the initial packet created
    return iPacket;
    }

const HBufC8* CDataSegmenter::NextPacket()
    {
    HBufC8* result = iPacket;
    TPtr8 packetPtr = iPacket->Des();

    // If there is some payload left over
    if (iPayloadBufPtr.Length() > 0)
        {
        // Reset the packet buffer
        packetPtr.Zero();

        // Append the additional packet header
        packetPtr.Append(iAdditionalHeaderByte);

        // Determine how much payload to copy, minimum of what's left and what
        // can fit in the packet
        TInt dataToCopy = Min((iMTU - 1), iPayloadBufPtr.Length());

        // Copy payload into the packet buffer
        packetPtr.Append(iPayloadBufPtr.Mid(0, dataToCopy));

        // Update the payload pointer
        iPayloadBufPtr.Set(iPayloadBufPtr.Mid(dataToCopy));
        }
    else if (packetPtr.Length() == iMTU)
        {
        // No payload left, but last packet was full, so we must send
        // an additional packet with just the header
        packetPtr.Zero();
        packetPtr.Append(iAdditionalHeaderByte);
        }
    else
        {
        // No more packets
        result = 0;
        }

    return result;
    }

void CDataSegmenter::Reset()
    {
    // If a packet has been allocated, then reset the data
    if (iPacket)
        {
        TPtr8 packetPtr = iPacket->Des();
        packetPtr.Zero();
        }

    // Reset the payload pointer to NULL
    iPayloadBufPtr.Set(TPtrC8(0, 0));
    }

void CDataSegmenter::ConstructL()
    {
    // No work to do
    }