// 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:
//

/**
 @file
 @internalComponent
*/

#ifndef HCTLBCSPFRAMEQUEUE_H
#define HCTLBCSPFRAMEQUEUE_H

#include <e32base.h>

// To Turn on window debuggng #define _DEBUG_WINDOW
#undef _DEBUG_WINDOW

class CHCTLBcspSequencer;
class CHCTLBcsp;
class CTxHctlBcspFrame;

NONSHARABLE_CLASS(CHCTLBcspWindow) : public CBase
/**
Window and associated functions to contain a queue of frames
handles acknowledgement of a particular received frame and moves the window onwards
within the scope of total number of sequence IDs

Is only used by CHCTLBcspFrameQueue
*/
	{
public:
	static CHCTLBcspWindow *NewL(TInt aWindowSize, TInt aFrameSize, TInt aNumberOfSeqIds);
	~CHCTLBcspWindow();

	TInt FreeFrames();

    CTxHctlBcspFrame* WriteFrame(); // Gets the write frame and moves the WritePosn
	CTxHctlBcspFrame* ReadFrame();  // Gets the read frame and moves the ReadPosn

	TBool Acknowledged(TInt AckNo);
	TInt StartOfWindow() const;
 	void Reset();

private:
	void ConstructL(TInt aFrameSize);
	CHCTLBcspWindow(TInt aWindowSize, TInt aNumberOfSeqIds);

	// Two simple inline private methods to reduce complexity of code whilst maintaining
	// efficiency
	TInt ToSeqId(TInt aIndex) const;
	TInt ToWindowIndex(TInt aSeqId) const; 
	void IncrementSeqId(TInt &aSeqId) const;
	CTxHctlBcspFrame *GetFrame(TInt aIndex);

	// Internal consistency checking for the class
    void __DbgTestInvariant() const;
	
#ifdef _DEBUG_WINDOW
	void TraceQueue();
	void TraceWindowVars() const;
#endif


private:
	TInt iStartOfWindow;
	TInt iReadPosition;
	TInt iHighReadPosition;
	TInt iWritePosition;
	TInt iEndOfWindow;
	TInt iWindowSize;
	TInt iNumberOfSeqIds;
	TSglQue<CTxHctlBcspFrame> iFrameQue;

	// This class stores most of its indices as SequneceIds, the only exception being
	// iWindowSize which is used in the conversion between SequenceIds and WindowIndex.
	//
	//   SequenceIds          Window Index
	//                     |
	//   iStartOfWindow    +   .
	//                     |   .
	//   iReadIndex        |   .
	//                     |   .
	//   iHighReadIndex    |   .
	//                     |   .
	//   iWriteIndex       |   .
	//                     |   .
	//   iEndOfWindow      +   iWindowSize
	//                     |
	//                     |
	//                     |
	//   iNumberOfSeqIds   |
	};

NONSHARABLE_CLASS(CHCTLBcspFrameQueue) : public CBase
/**
This is used by CHCTLBcsp to queue frames for transmission
the frames queued are stored in CHCTLBcspWindow
there are two windows used 
	one for reliable frames
	one for unreliable frames
*/
	{
public:
	static CHCTLBcspFrameQueue* NewL(CHCTLBcsp &aBcsp);
	~CHCTLBcspFrameQueue();

	void SetSequencer(CHCTLBcspSequencer& aSequencer);

	// Methods called by sequencer
	// Gets the next frame for sending 
	// (aFrame is the slip encoded frame
	//  returned by this method)
	//
	// returns: -
	//
	// KErrNone          - all is fine
	// KErrNothingToSend - nothing 
	//                     available to
	//                     send
	// KErrMaxRetries    - exceeded max 
	//                     retries for a
	//                     frame
	TInt GetNextFrame(TDesC8* &aFrame, TBool& aIsReliable);

	TBool AckReceived(TInt aAckValue); // Ack has been Received
	void AckTimeout();                 // Rx Ack Timer has expired

	// Methods called by CHCTLBcsp
	TInt AddReliableFrame  (const TDesC8 &aData, TUint8 aProtocolId);
	void AddUnreliableFrame(const TDesC8 &aData, TUint8 aProtocolId, 
												 TUint8 aAck,
												 TBool aCRCEnabled);

	void AddUnreliableFrame(TUint8 aProtocolId, 
							TUint8 aAck,
							TBool aCRCEnabled);
	void Reset();

private:
	void CanSend(); 
	void ConstructL();
	CHCTLBcspFrameQueue(CHCTLBcsp& aBcsp);

private:
	// Not owned by this class
	CHCTLBcspSequencer* iSequencer; // For calls to Wakeup()
	CHCTLBcsp& iBcsp; // For calls to CanSend()

	// Owned by this class
	CHCTLBcspWindow* iReliableQueue;
	CHCTLBcspWindow* iUnreliableQueue;

	HBufC8* iSlipEncodedFrame;
	};

#endif // HCTLBCSPFRAMEQUEUE_H