/*
DSFML - The Simple and Fast Multimedia Library for D

Copyright (c) 2013 - 2015 Jeremy DeHaan (dehaan.jeremiah@gmail.com)

This software is provided 'as-is', without any express or implied warranty.
In no event will the authors be held liable for any damages arising from the use of this software.

Permission is granted to anyone to use this software for any purpose, including commercial applications,
and to alter it and redistribute it freely, subject to the following restrictions:

1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software.
If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.

2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.

3. This notice may not be removed or altered from any source distribution
*/

///A module contianing the Packet class.
module dsfml.network.packet;

/**
 *Utility class to build blocks of data to transfer over the network.
 *
 *Packets provide a safe and easy way to serialize data, in order to send it over the network using sockets (sf::TcpSocket, sf::UdpSocket).
 */
class Packet
{
	package sfPacket* sfPtr;
	
	///Default constructor
	this()
	{
		sfPtr = sfPacket_create();
	}
	
	///Destructor
	~this()
	{
		import dsfml.system.config;
		mixin(destructorOutput);
		sfPacket_destroy(sfPtr);
	}

	///Get a slice of the data contained in the packet.
	///
	///Returns: Slice containing the data.
	const(void)[] getData() const
	{
		return sfPacket_getData(sfPtr)[0..sfPacket_getDataSize(sfPtr)];
	}

	///Append data to the end of the packet.
	///Params:
    ///		data = Pointer to the sequence of bytes to append.
	void append(const(void)[] data)
	{
		sfPacket_append(sfPtr, data.ptr, void.sizeof*data.length);
	}

	
	///Test the validity of a packet, for reading
	///
	///This function allows to test the packet, to check if
	///a reading operation was successful.
	///
	///A packet will be in an invalid state if it has no more
	///data to read.
	///
	///Returns: True if last data extraction from packet was successful.
	bool canRead() const
	{
		return (sfPacket_canRead(sfPtr));
	}

	///Clear the packet.
	///
	///After calling Clear, the packet is empty.
	void clear()
	{
		sfPacket_clear(sfPtr);
	}

	///Tell if the reading position has reached the end of the packet.
	///
	///This function is useful to know if there is some data left to be read, without actually reading it.
	///
	///Returns: True if all data was read, false otherwise.
	bool endOfPacket() const
	{
		return (sfPacket_endOfPacket(sfPtr));
	}

	///Reads a bool from the packet.
	bool readBool()
	{
		return cast(bool)readByte();
	}

	///Reads a byte from the packet.
	byte readByte()
	{
		return sfPacket_readInt8(sfPtr);
	}
	
	///Reads a ubyte from the packet.
	ubyte readUbyte()
	{
		return sfPacket_readUint8(sfPtr);
	}
	
	///Reads a short from the packet.
	short readShort()
	{
		return sfPacket_readInt16(sfPtr);
	}

	///Reads a ushort from the packet.
	ushort readUshort()
	{
		return sfPacket_readUint16(sfPtr);
	}

	///Reads a int from the packet.
	int readInt()
	{
		return sfPacket_readInt32(sfPtr);
	}

	///Reads a uint from the packet.
	uint readUint()
	{
		return sfPacket_readUint32(sfPtr);
	}
	
	///Reads a float from the packet.
	float readFloat()
	{
		return sfPacket_readFloat(sfPtr);
	}
	
	///Reads a double from the packet.
	double readDouble()
	{
		return sfPacket_readDouble(sfPtr);
	}
	
	///Reads a string from the packet.
	string readString()
	{
		import std.conv;

		//get string length
		uint length = readUint();
		char[] temp = new char[](length);

		//read each char of the string and put it in. 
		for(int i = 0; i < length;++i)
		{
			temp[i] = cast(char)readUbyte();
		}

		return temp.to!string();
	}
	
	///Reads a wstring from the packet.
	wstring readWstring()
	{
		import std.conv;

		//get string length
		uint length = readUint();
		wchar[] temp = new wchar[](length);
		
		//read each wchar of the string and put it in. 
		for(int i = 0; i < length;++i)
		{
			temp[i] = cast(wchar)readUshort();
		}
		
		return temp.to!wstring();
	}

	///Reads a dstring from the packet.
	dstring readDstring()
	{
		import std.conv;

		//get string length
		uint length = readUint();
		dchar[] temp = new dchar[](length);
		
		//read each dchar of the string and put it in. 
		for(int i = 0; i < length;++i)
		{
			temp[i] = cast(dchar)readUint();
		}
		
		return temp.to!dstring();
	}

	///Write a bool the the end of the packet.
	void writeBool(bool value)
	{
		writeUbyte(cast(ubyte)value);
	}

	///Write a byte the the end of the packet.
	void writeByte(byte value)
	{
		sfPacket_writeInt8(sfPtr,value);
	}

	///Write a ubyte the the end of the packet.
	void writeUbyte(ubyte value)
	{
		sfPacket_writeUint8(sfPtr, value);
	}
	
	///Write a short the the end of the packet.
	void writeShort(short value)
	{
		sfPacket_writeInt16(sfPtr, value);
	}
	
	///Write a ushort the the end of the packet.
	void writeUshort(ushort value)
	{
		sfPacket_writeUint16(sfPtr, value);
	}
	
	///Write a int the the end of the packet.
	void writeInt(int value)
	{
		sfPacket_writeInt32(sfPtr, value);
	}
	
	///Write a uint the the end of the packet.
	void writeUint(uint value)
	{
		sfPacket_writeUint32(sfPtr, value);
	}
	
	///Write a float the the end of the packet.
	void writeFloat(float value)
	{
		sfPacket_writeFloat(sfPtr, value);
	}

	///Write a double the the end of the packet.
	void writeDouble(double value)
	{
		sfPacket_writeDouble(sfPtr, value);
	}
	
	///Write a string the the end of the packet.
	void writeString(string value)
	{
		//write length of string.
		writeUint(cast(uint)value.length);
		//write append the string data

		append(value);
	}
	
	///Write a wstring the the end of the packet.
	void writeWstring(wstring value)
	{
		//write length of string.
		writeUint(cast(uint)value.length);
		//write append the string data
		for(int i = 0; i<value.length;++i)
		{
			writeUshort(cast(ushort)value[i]);
		}
	}

	///Write a dstring the the end of the packet.
	void writeDstring(dstring value)
	{
		//write length of string.
		writeUint(cast(uint)value.length);
		//write append the string data
		for(int i = 0; i<value.length;++i)
		{
			writeUint(cast(uint)value[i]);
		}
	}

	///Called before the packet is sent over the network.
	///
	///This function can be defined by derived classes to transform the data before it is sent; this can be used for compression, encryption, etc.
	///The function must return an array of the modified data, as well as the number of bytes pointed. The default implementation provides the packet's data without transforming it.
	///
	///Returns:  Array of bytes to send
	const(void)[] onSend()
	{
		return getData();
	}

	///Called after the packet is received over the network.
	///
	///This function can be defined by derived classes to transform the data after it is received; this can be used for uncompression, decryption, etc.
	///The function receives an array of the received data, and must fill the packet with the transformed bytes. The default implementation fills the packet directly without transforming the data.
	///
	///Params:
    //		data = Array of the received bytes. 
	void onRecieve(const(void)[] data)
	{
		append(data);
	}

	version(unittest)
	{
		shared static this()
		{
    		//XInitThreads();
		}


	}
	
}



unittest
{
	//TODO: Expand to use more of the mehtods found in Packet
	version(DSFML_Unittest_Network)
	{
		import std.stdio;


		import dsfml.network.socket;
		import dsfml.network.tcpsocket;
		import dsfml.network.tcplistener;
		import dsfml.network.ipaddress;
		import dsfml.system.time;

		
		writeln("Unittest for Packet");
		//socket connecting to server
		auto clientSocket = new TcpSocket();
		
		//listener looking for new sockets
		auto listener = new TcpListener();
		listener.listen(46932);
		
		//get our client socket to connect to the server
		clientSocket.connect(IpAddress.LocalHost, 46932);
		
		
		
		//packet to send data
		auto sendPacket = new Packet();
		
		
		//Packet to receive data
		auto receivePacket = new Packet();
		
		//socket on the server side connected to the client's socket
		auto serverSocket = new TcpSocket();
		
		//accepts a new connection and binds it to the socket in the parameter
		listener.accept(serverSocket);
		
		//Let's greet the server!
		sendPacket.writeString("Hello, I'm a client!");
		clientSocket.send(sendPacket);
		
		//And get the data on the server side
		serverSocket.receive(receivePacket);
		
		//What did we get from the client?
		writeln("Gotten from client: " ,receivePacket.readString());
		
		//clear the packets to send/get new information
		sendPacket.clear();
		receivePacket.clear();
		
		//Respond back to the client
		sendPacket.writeString("Hello, I'm your server.");
		
		serverSocket.send(sendPacket);

		clientSocket.receive(receivePacket);


		
		writeln("Gotten from server: ", receivePacket.readString());
		
		clientSocket.disconnect();
		
		writeln("Done!");
		writeln();
	}
}

package extern(C):

struct sfPacket;

///Create a new packet
sfPacket* sfPacket_create();


///Create a new packet by copying an existing one
sfPacket* sfPacket_copy(const sfPacket* packet);


///Destroy a packet
void sfPacket_destroy(sfPacket* packet);


///Append data to the end of a packet
void sfPacket_append(sfPacket* packet, const void* data, size_t sizeInBytes);


///Clear a packet
void sfPacket_clear(sfPacket* packet);


///Get a pointer to the data contained in a packet
const(void)* sfPacket_getData(const sfPacket* packet);


///Get the size of the data contained in a packet
size_t sfPacket_getDataSize(const sfPacket* packet);


///Tell if the reading position has reached the end of a packet
bool sfPacket_endOfPacket(const sfPacket* packet);


///Test the validity of a packet, for reading
bool sfPacket_canRead(const sfPacket* packet);


///Functions to extract data from a packet
bool    sfPacket_readBool(sfPacket* packet);
byte    sfPacket_readInt8(sfPacket* packet);
ubyte   sfPacket_readUint8(sfPacket* packet);
short   sfPacket_readInt16(sfPacket* packet);
ushort  sfPacket_readUint16(sfPacket* packet);
int     sfPacket_readInt32(sfPacket* packet);
uint    sfPacket_readUint32(sfPacket* packet);
float    sfPacket_readFloat(sfPacket* packet);
double   sfPacket_readDouble(sfPacket* packet);
///void     sfPacket_readString(sfPacket* packet, char* string);
///void     sfPacket_readWideString(sfPacket* packet, wchar_t* string);///Remove in lieu of readUint16 and readUint32 for W and D chars in D?

///Functions to insert data into a packet
void sfPacket_writeBool(sfPacket* packet, bool);
void sfPacket_writeInt8(sfPacket* packet, byte);
void sfPacket_writeUint8(sfPacket* packet, ubyte);
void sfPacket_writeInt16(sfPacket* packet, short);
void sfPacket_writeUint16(sfPacket* packet, ushort);
void sfPacket_writeInt32(sfPacket* packet, int);
void sfPacket_writeUint32(sfPacket* packet, uint);
void sfPacket_writeFloat(sfPacket* packet, float);
void sfPacket_writeDouble(sfPacket* packet, double);