#ifndef COMMON_H
#define COMMON_H
 
 
#include <cstdio>
 
 
#define HideDebugMSG(...) do {} while(0)
 
#ifdef NDEBUG
#	define ShowDebugMSG(...) do {} while(0)
#else
#	define ShowDebugMSG(...) do { \
		printf("DEBUG %16lld %s:%s:%d:", monotonicTime(), __FILE__, __func__, __LINE__); \
		printf(" " __VA_ARGS__); \
		printf("\n"); \
		fflush(stdout); \
	} 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