//@C Copyright Notice
 //@C ================
 //@C This file is part of CPSW. It is subject to the license terms in the LICENSE.txt
 //@C file found in the top-level directory of this distribution and at
 //@C https://confluence.slac.stanford.edu/display/ppareg/LICENSE.html.
 //@C
 //@C No part of CPSW, including this file, may be copied, modified, propagated, or
 //@C distributed except according to the terms contained in the LICENSE.txt file.

#ifndef CPSW_PROTO_MOD_DEPACK_H
#define CPSW_PROTO_MOD_DEPACK_H

#include <boost/atomic.hpp>
#include <vector>

#include <cpsw_api_user.h>
#include <cpsw_proto_mod.h>
#include <cpsw_thread.h>

#include <pthread.h>

using boost::atomic;
using boost::memory_order_relaxed;
using std::vector;

typedef unsigned FrameID;
typedef unsigned FragID;
typedef unsigned ProtoVersion;

class CProtoModDepack;
typedef shared_ptr<CProtoModDepack> ProtoModDepack;

class IProtoModDepack : public virtual IProtoMod {
};

class CAxisFrameHeader {
private:
	FrameID      frameNo_;
	FragID       fragNo_;
	ProtoVersion vers_;
	uint8_t      tDest_;
	uint8_t      tId_;
	uint8_t      tUsr1_;

public:
	static const unsigned VERSION_BIT_OFFSET  =  0;
	static const unsigned VERSION_BIT_SIZE    =  4;
	static const unsigned FRAME_NO_BIT_OFFSET =  4;
	static const unsigned FRAME_NO_BIT_SIZE   = 12;
	static const unsigned FRAG_NO_BIT_OFFSET  = 16;
	static const unsigned FRAG_NO_BIT_SIZE    = 24;
	static const unsigned FRAG_MAX            = (1<<FRAG_NO_BIT_SIZE) - 1;

	static const unsigned TDEST_BIT_OFFSET    = 40;
	static const unsigned TDEST_BIT_SIZE      =  8;
	static const unsigned TID_BIT_OFFSET      = 48;
	static const unsigned TID_BIT_SIZE        =  8;
	static const unsigned TUSR1_BIT_OFFSET    = 56;
	static const unsigned TUSR1_BIT_SIZE      =  8;

	static const unsigned FRAG_FRST_BIT       =  1; // SOF in tUSR1
	static const unsigned FRAG_LAST_BIT       =  7; // EOF in tail byte

	static const unsigned VERSION_0           =  0;

	static const unsigned V0_HEADER_SIZE      =  8;

	static const unsigned V0_TAIL_SIZE        =  1;

	class CAxisFrameNoAllocator {
	private:
		atomic<FrameID> frameNo_;
	public:
		CAxisFrameNoAllocator()
		:frameNo_(0)
		{
		}

		FrameID newFrameID()
		{
		FrameID id;
		unsigned shft = (8*sizeof(FrameID)-FRAME_NO_BIT_SIZE);
			id = frameNo_.fetch_add( (1<<shft), memory_order_relaxed ) >> shft;
			return id & ((1<<FRAME_NO_BIT_SIZE) - 1);
		}
	};

	void         setSOF(bool v)
	{
		if ( v )
			tUsr1_ |=  (1<<FRAG_FRST_BIT);
		else
			tUsr1_ &= ~(1<<FRAG_FRST_BIT);
	}

	CAxisFrameHeader(unsigned frameNo = 0, unsigned fragNo = 0, unsigned tDest = 0)
	:frameNo_(frameNo),
	 fragNo_(fragNo),
	 vers_(VERSION_0),
	 tDest_( tDest ),
	 tId_(0),
	 tUsr1_(0)
	{
		setSOF( fragNo == 0 );
	}

	bool parse(uint8_t *hdrBase, size_t hdrSize);

	class InvalidHeaderException {};

	static unsigned parseVersion(uint8_t *hdrBase, size_t hdrSize)
	{
		return (hdrBase[0] >> VERSION_BIT_OFFSET) & ( (1<<VERSION_BIT_SIZE) - 1 );
	}

	// some quick helpers
	static unsigned parseHeaderSize(uint8_t *hdrBase, size_t hdrSize)
	{
		if ( parseVersion(hdrBase, hdrSize) != VERSION_0 )
			throw InvalidHeaderException();
		return V0_HEADER_SIZE;
	}

	static unsigned parseTailSize(uint8_t *hdrBase, size_t hdrSize)
	{
		if ( parseVersion(hdrBase, hdrSize) != VERSION_0 )
			throw InvalidHeaderException();
		return V0_TAIL_SIZE;
	}


	static unsigned parseTDest(uint8_t *hdrBase, size_t hdrSize)
	{
		if ( parseVersion(hdrBase, hdrSize) != VERSION_0 || hdrSize < V0_HEADER_SIZE )
			throw InvalidHeaderException();
		if ( ( TDEST_BIT_OFFSET % 8 != 0 ) || ( TDEST_BIT_SIZE != 8 ) )
			throw InternalError("Implementation doesn't match header format");
		return hdrBase[ TDEST_BIT_OFFSET/8 ];
	}

	static void insertTDest(uint8_t *hdrBase, size_t hdrSize, uint8_t tdest)
	{
		if ( parseVersion(hdrBase, hdrSize) != VERSION_0 || hdrSize < V0_HEADER_SIZE )
			throw InvalidHeaderException();
		if ( ( TDEST_BIT_OFFSET % 8 != 0 ) || ( TDEST_BIT_SIZE != 8 ) )
			throw InternalError("Implementation doesn't match header format");
		hdrBase[ TDEST_BIT_OFFSET/8 ] = tdest;
	}

	CAxisFrameHeader(uint8_t *hdrBase, size_t hdrSize)
	{
		if ( ! parse(hdrBase, hdrSize) )
			throw InvalidHeaderException();
	}

	void insert(uint8_t *hdrBase, size_t hdrSize);

	FrameID      getFrameNo() { return frameNo_; }
	FragID       getFragNo()  { return fragNo_;  }
	ProtoVersion getVersion() { return vers_;    }
	uint8_t      getTDest()   { return tDest_;   }
	uint8_t      getTUsr1()   { return tUsr1_;   }
	bool         getSOF()     { return !! (tUsr1_ & (1<<FRAG_FRST_BIT)); }

	void         setFrameNo(FrameID frameNo)
	{
		frameNo_ = frameNo;
	}

	void         setFragNo(FragID   fragNo)
	{
		fragNo_  = fragNo;
		setSOF( fragNo_ == 0 );
	}

	void         setTDest(uint8_t   tDest)
	{
		tDest_   = tDest;
	}

	void         setTUsr1(uint8_t   tUsr1)
	{
		tUsr1_   = tUsr1;
	}

	static FrameID moduloFrameSz(FrameID id)
	{
		return (id & ((1<<FRAME_NO_BIT_SIZE) - 1));
	}

	static int   signExtendFrameNo(FrameID x)
	{
		if ( x & (1<<(FRAME_NO_BIT_SIZE-1)) )
			 x |= ~((1<<FRAME_NO_BIT_SIZE)-1);
		return x;
	}

	size_t       getSize()     { return V0_HEADER_SIZE; }

	size_t       getTailSize() { return V0_TAIL_SIZE;   }

	static bool getTailEOF(uint8_t *tailbuf)           { return (*tailbuf) & (1<<FRAG_LAST_BIT);    }
	static void setTailEOF(uint8_t *tailbuf, bool eof) { if ( eof ) (*tailbuf) |= (1<<FRAG_LAST_BIT); else (*tailbuf) &= ~(1<<FRAG_LAST_BIT); }

	static void iniTail(uint8_t *tailbuf)              { *tailbuf = 0; }

};

class CFrame {
public:
	static const FrameID NO_FRAME = (FrameID)(1<<24); // so that abs(frame-NO_FRAME) never is inside any window
	static const FragID  NO_FRAG  = (FragID)-2; // so that NO_FRAG + 1 is not a valid ID
protected:
	BufChain         prod_;
	FragID           nFrags_;
	FrameID          frameID_;
	FragID           oldestFrag_;
	FragID           lastFrag_;
	CTimeout         timeout_;
	vector<BufChain> fragWin_;
	bool             isComplete_;
	bool             running_;

	CFrame(unsigned winSize)
	:nFrags_( 0 ),
	 frameID_( NO_FRAME ),
	 oldestFrag_( 0 ),
	 lastFrag_( NO_FRAG ),
	 fragWin_( winSize ),
	 isComplete_( false ),
	 running_( false )
	{
	}

	bool isComplete()
	{
		return isComplete_;
	}

	void release(unsigned *ctr);
	void updateChain();

	friend class CProtoModDepack;
};

class CProtoModDepack : public CProtoMod, public CRunnable {
private:
	unsigned badHeaderDrops_;
	unsigned oldFrameDrops_;
	unsigned newFrameDrops_;
	unsigned oldFragDrops_;
	unsigned newFragDrops_;
	unsigned duplicateFragDrops_;
	unsigned duplicateLastSeen_;
	unsigned noLastSeen_;
	unsigned fragsAccepted_;
	unsigned framesAccepted_;
	unsigned oqueueFullDrops_;
	unsigned evictedFrames_;
	unsigned incompleteDrops_;
	unsigned emptyDrops_;
	unsigned timedOutFrames_;
	unsigned pastLastDrops_;

	CTimeout timeout_;

	CAxisFrameHeader::CAxisFrameNoAllocator frameIdGen_;

protected:
	unsigned frameWinSize_;
	unsigned fragWinSize_;

	FrameID        oldestFrame_;
	vector<CFrame> frameWin_;

	virtual void processBuffer(BufChain);

	virtual void frameSync(CAxisFrameHeader *);

	virtual void* threadBody();

	virtual void modStartup();
	virtual void modShutdown();

	virtual void releaseFrames(bool onlyComplete);

	virtual bool releaseOldestFrame(bool onlyComplete);

	virtual BufChain processOutput(BufChain bc);

	virtual void startTimeout(CFrame *frame);

	virtual unsigned toFrameIdx(unsigned frameNo) { return frameNo & ( frameWinSize_ - 1 ); }
	virtual unsigned toFragIdx(unsigned fragNo)   { return fragNo  & ( fragWinSize_  - 1 ); }

	virtual int      iMatch(ProtoPortMatchParams *cmp);

	CProtoModDepack( CProtoModDepack &orig, Key &k );

public:
	CProtoModDepack(Key &k, unsigned oqueueDepth, unsigned ldFrameWinSize, unsigned ldFragWinSize, CTimeout timeout);

	virtual ~CProtoModDepack();

	virtual void dumpInfo(FILE *f);

	virtual CProtoModDepack * clone(Key &k) { return new CProtoModDepack( *this, k ); }

	virtual const char *getName() const { return "AXIS Depack"; }

	virtual void dumpYaml(YAML::Node &node) const;
};

#endif