#ifndef COMMON_H

#define COMMON_H

#include <cstdio></cstdio>

#define logf(...) do { fprintf(stdout, __VA_ARGS__); fflush(stdout); } while(0)

#define HideDebugMSG(...) do {} while(0)

#ifdef NDEBUG

#	define ShowDebugMSG(...) do {} while(0)

#else

#	define ShowDebugMSG(...) do { \

		logf("DEBUG %16lld %s:%s:%d:", monotonicTime(), __FILE__, __func__, __LINE__); \

		logf(" " __VA_ARGS__); \

		logf("\n"); \

	} while(0)

#endif

enum {

	PACKET_SIZE     = 470,

	PACKETS_COUNT   = 8*PACKET_SIZE,

	TCP_BUFFER_SIZE = PACKET_SIZE*PACKETS_COUNT,

	CRYPT_BLOCK     = 128,

	HASH_SIZE       = 32,

};

enum : unsigned short {

	CMD_SHIFT   = 12,

	CMD_MASK    = (unsigned short)(0xffff << CMD_SHIFT),

	SIZE_MASK   = (unsigned short)(~CMD_MASK),

	CMD_DATA      = 0,

	CMD_CONFIRM   = 1,

	CMD_TERM      = 2,

	CMDMAX        = 3,

};

typedef unsigned long long Time;

Time monotonicTime();

Time globalTime();

const char* bitsToString(const void *data, int size);

inline bool cycleLequal(unsigned int a, unsigned int b)

	{ return (b - a) <= 0x7fffffff; }

inline bool cycleLess(unsigned int a, unsigned int b)

	{ return !cycleLequal(b, a); }

inline bool timeLequal(Time a, Time b)

	{ return (b - a) <= 0x7fffffffffffffffull; }

inline bool timeLess(Time a, Time b)

	{ return !timeLequal(b, a); }

class Address {

public:

	union {

		struct { unsigned int ipUInt; };

		struct { unsigned char ip[4]; };

	};

	unsigned short port;

	inline Address(): ipUInt(), port() { }

	inline bool operator<(const Address &other) const {

		return ipUInt < other.ipUInt ? true

		     : other.ipUInt < ipUInt ? false

		     : port < other.port;

	}

	void print() const;

};

class ConnId {

public:

	Address address;

	unsigned int id;

	inline ConnId(): id() { }

	inline bool operator<(const ConnId &other) const {

		return address < other.address ? true

				: other.address < address ? false

				: id < other.id;

	}

};

struct __attribute__((__packed__)) Packet {

	unsigned int connId;

	unsigned int index;

	unsigned short cmdSize;

	unsigned char payload[PACKET_SIZE];

	inline Packet():

		connId(), index(), cmdSize(), payload() { }

	inline int getSize() const

		{ return cmdSize & SIZE_MASK; }

	inline int getCommand() const

		{ return cmdSize >> CMD_SHIFT; }

	inline void init(

		unsigned int connId,

		unsigned int index,

		unsigned short cmd,

		unsigned short size )

	{

		this->connId = connId;

		this->index = index;

		this->cmdSize = (cmd << CMD_SHIFT) | size;

	}

};

enum {

	FULL_PACKET_SIZE  = sizeof(Packet),

	HEADER_SIZE       = FULL_PACKET_SIZE - PACKET_SIZE,

	CRYPT_PACKET_SIZE = ((FULL_PACKET_SIZE + HASH_SIZE - 1)/CRYPT_BLOCK + 1)*CRYPT_BLOCK,

};

#endif