// ==============================================================
//	This file is part of MegaGlest (www.megaglest.org)
//
//	Copyright (C) 2012 Mark Vejvoda
//
//	You can redistribute this code and/or modify it under
//	the terms of the GNU General Public License as published
//	by the Free Software Foundation; either version 2 of the
//	License, or (at your option) any later version
// ==============================================================
#include "network_protocol.h"
#include <stdarg.h>
#include <cstring>
#include <ctype.h>
#include <stdio.h>
#include "data_types.h"
#include "util.h"
#include "leak_dumper.h"

using namespace Shared::Platform;
using namespace Shared::Util;

namespace Glest{ namespace Game{

#pragma pack(push, 1)

// macros for packing floats and doubles:
#define pack754_16(f) (pack754((f), 16, 5))
#define pack754_32(f) (pack754((f), 32, 8))
#define pack754_64(f) (pack754((f), 64, 11))
#define unpack754_16(i) (unpack754((i), 16, 5))
#define unpack754_32(i) (unpack754((i), 32, 8))
#define unpack754_64(i) (unpack754((i), 64, 11))

/*
** pack754() -- pack a floating point number into IEEE-754 format
*/
unsigned long long int pack754(long double f, unsigned bits, unsigned expbits)
{
	long double fnorm;
	int shift;
	long long sign, exp, significand;
	unsigned significandbits = bits - expbits - 1; // -1 for sign bit

	if (f == 0.0) return 0; // get this special case out of the way

	// check sign and begin normalization
	if (f < 0) { sign = 1; fnorm = -f; }
	else { sign = 0; fnorm = f; }

	// get the normalized form of f and track the exponent
	shift = 0;
	while(fnorm >= 2.0) { fnorm /= 2.0; shift++; }
	while(fnorm < 1.0) { fnorm *= 2.0; shift--; }
	fnorm = fnorm - 1.0;

	// calculate the binary form (non-float) of the significand data
	significand = fnorm * ((1LL<<significandbits) + 0.5f);

	// get the biased exponent
	exp = (long long)shift + ((1<<(expbits-1)) - 1); // shift + bias

	// return the final answer
	return (sign<<(bits-1)) | (exp<<(bits-expbits-1)) | significand;
}

/*
** unpack754() -- unpack a floating point number from IEEE-754 format
*/
long double unpack754(unsigned long long int i, unsigned bits, unsigned expbits)
{
	long double result;
	long long shift;
	unsigned bias;
	unsigned significandbits = bits - expbits - 1; // -1 for sign bit

	if (i == 0) return 0.0;

	// pull the significand
	result = (i&((1LL<<significandbits)-1)); // mask
	result /= (1LL<<significandbits); // convert back to float
	result += 1.0f; // add the one back on

	// deal with the exponent
	bias = (1<<(expbits-1)) - 1;
	shift = ((i>>significandbits)&((1LL<<expbits)-1)) - bias;
	while(shift > 0) { result *= 2.0; shift--; }
	while(shift < 0) { result /= 2.0; shift++; }

	// sign it
	result *= (i>>(bits-1))&1? -1.0: 1.0;

	return result;
}

/*
** packi16() -- store a 16-bit int into a char buffer (like htons())
*/
void packi16(unsigned char *buf, uint16 i)
{
	*buf++ = i>>8; *buf++ = i;
}

/*
** packi32() -- store a 32-bit int into a char buffer (like htonl())
*/
void packi32(unsigned char *buf, uint32 i)
{
	*buf++ = i>>24; *buf++ = i>>16;
	*buf++ = i>>8;  *buf++ = i;
}

/*
** packi64() -- store a 64-bit int into a char buffer (like htonl())
*/
void packi64(unsigned char *buf, uint64 i)
{
	*buf++ = i>>56; *buf++ = i>>48;
	*buf++ = i>>40; *buf++ = i>>32;
	*buf++ = i>>24; *buf++ = i>>16;
	*buf++ = i>>8;  *buf++ = i;
}

/*
** unpacki16() -- unpack a 16-bit int from a char buffer (like ntohs())
*/
int16 unpacki16(unsigned char *buf)
{
	uint16 i2 = ((uint16)buf[0]<<8) | buf[1];
	int16 i;

	// change unsigned numbers to signed
	if (i2 <= 0x7fffu) {
		i = i2;
	}
	else {
		i = -1 - (uint16)(0xffffu - i2);
		if(SystemFlags::VERBOSE_MODE_ENABLED) printf("IN [%s] [%d] [%d] [%d] [%u]\n",__FUNCTION__,buf[0],buf[1],i,i2);
	}

	return i;
}

/*
** unpacku16() -- unpack a 16-bit unsigned from a char buffer (like ntohs())
*/
uint16 unpacku16(unsigned char *buf)
{
	return ((uint16)buf[0]<<8) | buf[1];
}

/*
** unpacki32() -- unpack a 32-bit int from a char buffer (like ntohl())
*/
int32 unpacki32(unsigned char *buf)
{
	uint32 i2 = ((uint32)buf[0]<<24) |
	            ((uint32)buf[1]<<16) |
	            ((uint32)buf[2]<<8)  |
	                     buf[3];
	int32 i;

	// change unsigned numbers to signed
	if (i2 <= 0x7fffffffu) {
		i = i2;
	}
	else {
		i = -1 - (int32)(0xffffffffu - i2);
		if(SystemFlags::VERBOSE_MODE_ENABLED) printf("IN [%s] [%d] [%d] [%d] [%d] [%d] [%u]\n",__FUNCTION__,buf[0],buf[1],buf[2],buf[3],i,i2);
	}

	return i;
}

/*
** unpacku32() -- unpack a 32-bit unsigned from a char buffer (like ntohl())
*/
uint32 unpacku32(unsigned char *buf)
{
	return ((uint32)buf[0]<<24) |
	       ((uint32)buf[1]<<16) |
	       ((uint32)buf[2]<<8)  |
	       buf[3];
}

/*
** unpacki64() -- unpack a 64-bit int from a char buffer (like ntohl())
*/
int64 unpacki64(unsigned char *buf)
{
	uint64 i2 = ((uint64)buf[0]<<56) |
	              ((uint64)buf[1]<<48) |
	              ((uint64)buf[2]<<40) |
	              ((uint64)buf[3]<<32) |
	              ((uint64)buf[4]<<24) |
	              ((uint64)buf[5]<<16) |
	              ((uint64)buf[6]<<8)  |
	                       buf[7];
	int64 i;

	// change unsigned numbers to signed
	if (i2 <= 0x7fffffffffffffffull) {
		i = i2;
	}
	else {
		i = -1 -(int64)(0xffffffffffffffffull - i2);
		if(SystemFlags::VERBOSE_MODE_ENABLED) printf("IN [%s] [%d] [%d] [%d] [%d] [%d] [%d] [%d] [%d] [" MG_I64_SPECIFIER "] [" MG_I64U_SPECIFIER "]\n",__FUNCTION__,buf[0],buf[1],buf[2],buf[3],buf[4],buf[5],buf[6],buf[7],i,i2);
	}

	return i;
}

/*
** unpacku64() -- unpack a 64-bit unsigned from a char buffer (like ntohl())
*/
uint64 unpacku64(unsigned char *buf)
{
	return ((uint64)buf[0]<<56) |
	       ((uint64)buf[1]<<48) |
	       ((uint64)buf[2]<<40) |
	       ((uint64)buf[3]<<32) |
	       ((uint64)buf[4]<<24) |
	       ((uint64)buf[5]<<16) |
	       ((uint64)buf[6]<<8)  |
	       buf[7];
}

/*
** pack() -- store data dictated by the format string in the buffer
**
**   bits |signed   unsigned   float   string
**   -----+----------------------------------
**      8 |   c        C
**     16 |   h        H         f
**     32 |   l        L         d
**     64 |   q        Q         g
**      - |                               s
**
**  (16-bit unsigned length is automatically prepended to strings)
*/

unsigned int pack(unsigned char *buf, const char *format, ...) {
	va_list ap;

	int8 c;              // 8-bit
	uint8 C;

	int16 h;                      // 16-bit
	uint16 H;

	int32 l;                 // 32-bit
	uint32 L;

	int64 q;            // 64-bit
	uint64 Q;

	float f;                    // floats
	double d;
	long double g;
	unsigned long long int fhold;

	char *s;                    // strings
	uint16 len;

	unsigned int size = 0;

	uint16 maxstrlen=0;

	unsigned char *bufStart = buf;

	va_start(ap, format);

	for(; *format != '\0'; format++) {
		switch(*format) {
		case 'c': // 8-bit
			size += 1;
			c = (int8)va_arg(ap, int); // promoted
			*buf++ = (unsigned char)c;

			if(SystemFlags::VERBOSE_MODE_ENABLED) printf("pack int8 = %d [%X] c = %d [%X] buf pos = %lu\n",*(buf-1),*(buf-1),c,c,(unsigned long)(buf - bufStart));
			break;

		case 'C': // 8-bit unsigned
			size += 1;
			C = (uint8)va_arg(ap, unsigned int); // promoted
			*buf++ = (unsigned char)C;

			if(SystemFlags::VERBOSE_MODE_ENABLED) printf("pack uint8 = %u [%X] C = %u [%X] buf pos = %lu\n",*(buf-1),*(buf-1),C,C,(unsigned long)(buf - bufStart));
			break;

		case 'h': // 16-bit
			size += 2;
			h = (int16)va_arg(ap, int);
			packi16(buf, h);
			buf += 2;

			if(SystemFlags::VERBOSE_MODE_ENABLED) printf("pack int16 = %d [%X] h = %d [%X] buf pos = %lu\n",*(buf-2),*(buf-2),h,h,(unsigned long)(buf - bufStart));
			break;

		case 'H': // 16-bit unsigned
			size += 2;
			H = (uint16)va_arg(ap, unsigned int);
			packi16(buf, H);
			buf += 2;

			if(SystemFlags::VERBOSE_MODE_ENABLED) printf("pack uint16 = %u [%X] H = %u [%X] buf pos = %lu\n",*(buf-2),*(buf-2),H,H,(unsigned long)(buf - bufStart));
			break;

		case 'l': // 32-bit
			size += 4;
			l = va_arg(ap, int32);
			packi32(buf, l);
			buf += 4;

			if(SystemFlags::VERBOSE_MODE_ENABLED) printf("pack int32 = %d [%X] l = %d [%X] buf pos = %lu\n",*(buf-4),*(buf-4),l,l,(unsigned long)(buf - bufStart));
			break;

		case 'L': // 32-bit unsigned
			size += 4;
			L = va_arg(ap, uint32);
			packi32(buf, L);
			buf += 4;

			if(SystemFlags::VERBOSE_MODE_ENABLED) printf("pack uint32 = %u [%X] L = %u [%X] buf pos = %lu\n",*(buf-4),*(buf-4),L,L,(unsigned long)(buf - bufStart));
			break;

		case 'q': // 64-bit
			size += 8;
			q = va_arg(ap, int64);
			packi64(buf, q);
			buf += 8;

			//if(SystemFlags::VERBOSE_MODE_ENABLED) printf("pack int64 = " MG_I64_SPECIFIER " [%X] q = " MG_I64_SPECIFIER " [%lX] buf pos = %lu\n",(int64)*(buf-8),*(buf-8),q,q,(unsigned long)(buf - bufStart));
			if(SystemFlags::VERBOSE_MODE_ENABLED) printf("pack int64 = " MG_I64_SPECIFIER " [%X] q = " MG_I64_SPECIFIER " buf pos = %lu\n",(int64)*(buf-8),*(buf-8),q,(unsigned long)(buf - bufStart));
			break;

		case 'Q': // 64-bit unsigned
			size += 8;
			Q = va_arg(ap, uint64);
			packi64(buf, Q);
			buf += 8;

			if(SystemFlags::VERBOSE_MODE_ENABLED) printf("pack uint64 = " MG_I64U_SPECIFIER " [%X] Q = " MG_I64U_SPECIFIER " buf pos = %lu\n",(uint64)*(buf-8),*(buf-8),Q,(unsigned long)(buf - bufStart));
			break;

		case 'f': // float-16
			size += 2;
			f = (float)va_arg(ap, double); // promoted
			fhold = pack754_16(f); // convert to IEEE 754
			packi16(buf, fhold);
			buf += 2;
			break;

		case 'd': // float-32
			size += 4;
			d = va_arg(ap, double);
			fhold = pack754_32(d); // convert to IEEE 754
			packi32(buf, fhold);
			buf += 4;
			break;

		case 'g': // float-64
			size += 8;
			g = va_arg(ap, long double);
			fhold = pack754_64(g); // convert to IEEE 754
			packi64(buf, fhold);
			buf += 8;
			break;

		case 's': // string
			s = va_arg(ap, char*);
			len = (uint16)strlen(s);
			if (maxstrlen > 0 && len < maxstrlen)
				len = maxstrlen - 1;

			size += len + 2;
			packi16(buf, len);
			buf += 2;

			memcpy(buf, s, len);
			if(SystemFlags::VERBOSE_MODE_ENABLED) printf("pack string size = %d [%X] len = %d str [%s] buf pos = %lu\n",*(buf-2),*(buf-2),len,s,(unsigned long)(buf - bufStart));

			buf += len;
			break;

		default:
			if (isdigit(*format)) { // track max str len
				maxstrlen = maxstrlen * 10 + (*format-'0');
			}
			break;
		}

		if (!isdigit(*format)) maxstrlen = 0;

	}

	va_end(ap);

	return size;
}

/*
** unpack() -- unpack data dictated by the format string into the buffer
**
**   bits |signed   unsigned   float   string
**   -----+----------------------------------
**      8 |   c        C
**     16 |   h        H         f
**     32 |   l        L         d
**     64 |   q        Q         g
**      - |                               s
**
**  (string is extracted based on its stored length, but 's' can be
**  prepended with a max length)
*/
unsigned int unpack(unsigned char *buf, const char *format, ...) {
	va_list ap;

	int8 *c;              // 8-bit
	uint8 *C;

	int16 *h;                      // 16-bit
	uint16 *H;

	int32 *l;                 // 32-bit
	uint32 *L;

	int64 *q;            // 64-bit
	uint64 *Q;

	unsigned long long int fhold;

	char *s;
	uint16 len, maxstrlen=0, count;

	unsigned int size = 0;

	unsigned char *bufStart = buf;

	va_start(ap, format);

	for(; *format != '\0'; format++) {
		switch(*format) {
		case 'c': // 8-bit
			c = va_arg(ap, int8*);
//			if (*buf <= 0x7f) {
//				*c = *buf++;
//				size += 1;
//			} // re-sign
//			else {
//				*c = -1 - (unsigned char)(0xffu - *buf);
//			}
			*c = (int8)*buf++;
			size += 1;

			if(SystemFlags::VERBOSE_MODE_ENABLED) printf("unpack int8 = %d [%X] c = %d [%X] buf pos = %lu\n",*(buf-1),*(buf-1),*c,*c,(unsigned long)(buf - bufStart));
			break;

		case 'C': // 8-bit unsigned
			C = va_arg(ap, uint8*);
			*C = (uint8)*buf++;
			size += 1;

			if(SystemFlags::VERBOSE_MODE_ENABLED) printf("unpack uint8 = %u [%X] C = %u [%X] buf pos = %lu\n",*(buf-1),*(buf-1),*C,*C,(unsigned long)(buf - bufStart));
			break;

		case 'h': // 16-bit
			h = va_arg(ap, int16*);
			*h = unpacki16(buf);
			buf += 2;
			size += 2;

			if(SystemFlags::VERBOSE_MODE_ENABLED) printf("unpack int16 = %d [%X] h = %d [%X] buf pos = %lu\n",*(buf-2),*(buf-2),*h,*h,(unsigned long)(buf - bufStart));
			break;

		case 'H': // 16-bit unsigned
			H = va_arg(ap, uint16*);
			*H = unpacku16(buf);
			buf += 2;
			size += 2;

			if(SystemFlags::VERBOSE_MODE_ENABLED) printf("unpack uint16 = %u [%X] H = %u [%X] buf pos = %lu\n",*(buf-2),*(buf-2),*H,*H,(unsigned long)(buf - bufStart));
			break;

		case 'l': // 32-bit
			l = va_arg(ap, int32*);
			*l = unpacki32(buf);
			buf += 4;
			size += 4;

			if(SystemFlags::VERBOSE_MODE_ENABLED) printf("unpack int32 = %d [%X] l = %d [%X] buf pos = %lu\n",*(buf-4),*(buf-4),*l,*l,(unsigned long)(buf - bufStart));
			break;

		case 'L': // 32-bit unsigned
			L = va_arg(ap, uint32*);
			*L = unpacku32(buf);
			buf += 4;
			size += 4;

			if(SystemFlags::VERBOSE_MODE_ENABLED) printf("unpack uint32 = %u [%X] L = %u [%X] buf pos = %lu\n",*(buf-4),*(buf-4),*L,*L,(unsigned long)(buf - bufStart));
			break;

		case 'q': // 64-bit
			q = va_arg(ap, int64*);
			*q = unpacki64(buf);
			buf += 8;
			size += 8;

			if(SystemFlags::VERBOSE_MODE_ENABLED) printf("unpack int64 = " MG_I64_SPECIFIER " [%X] q = " MG_I64_SPECIFIER " buf pos = %lu\n",(int64)*(buf-8),*(buf-8),*q,(unsigned long)(buf - bufStart));
			break;

		case 'Q': // 64-bit unsigned
			Q = va_arg(ap, uint64*);
			*Q = unpacku64(buf);
			buf += 8;
			size += 8;

			if(SystemFlags::VERBOSE_MODE_ENABLED) printf("unpack uint64 = " MG_I64U_SPECIFIER " [%X] Q = " MG_I64U_SPECIFIER " buf pos = %lu\n",(uint64)*(buf-8),*(buf-8),*Q,(unsigned long)(buf - bufStart));
			break;

		case 'f': // float
			{
			float *f = va_arg(ap, float*);
			fhold = unpacku16(buf);
			*f = unpack754_16(fhold);
			buf += 2;
			size += 2;
			}
			break;

		case 'd': // float-32
			{
			double *d = va_arg(ap, double*);
			fhold = unpacku32(buf);
			*d = unpack754_32(fhold);
			buf += 4;
			size += 4;
			}
			break;

		case 'g': // float-64
			{
			long double *g = va_arg(ap, long double*);
			fhold = unpacku64(buf);
			*g = unpack754_64(fhold);
			buf += 8;
			size += 8;
			}
			break;

		case 's': // string
			s = va_arg(ap, char*);
			len = unpacku16(buf);
			buf += 2;
			if (maxstrlen > 0 && len > maxstrlen)
				count = maxstrlen - 1;
			else
				count = len;

			memcpy(s, buf, count);
			s[count] = '\0';
			if(SystemFlags::VERBOSE_MODE_ENABLED) printf("unpack string size = %d [%X] count = %d len = %d str [%s] buf pos = %lu\n",*(buf-2),*(buf-2),count,len,s,(unsigned long)(buf - bufStart));

			buf += len;
			size += len;
			break;

		default:
			if (isdigit(*format)) { // track max str len
				maxstrlen = maxstrlen * 10 + (*format-'0');
			}
			break;
		}

		if (!isdigit(*format)) maxstrlen = 0;
	}

	va_end(ap);

	return size;
}

#pragma pack(pop)

}}