#include "messages.h"

using namespace message;

/* MessageBase */

MessageBase::MessageBase() {
	type = MSG_TYPE_NONE;
}

uint8_t MessageBase::read_type(boost::asio::ip::tcp::socket& socket) {
	uint8_t type;
	boost::asio::read(socket, boost::asio::buffer(&type, sizeof(uint8_t)));

	return type;
}

void MessageBase::send(boost::asio::ip::tcp::socket& socket) {
	boost::asio::write(socket, boost::asio::buffer(&type, sizeof(type)));
	do_send(socket);
}

std::string MessageBase::read_string(boost::asio::ip::tcp::socket& socket) {
	uint16_t str_len;
	read(socket, str_len);

	std::string s;

	char *buf = new char[str_len];
	boost::asio::read(socket, boost::asio::buffer(buf, str_len));

	s.assign(buf, str_len);
	delete[] buf;

	return s;
}

void MessageBase::write_string(boost::asio::ip::tcp::socket& socket, std::string str) {
	uint16_t str_len = str.size();
	write(socket, str_len);

	boost::asio::write(socket, boost::asio::buffer(str));
}

/* Hello */

Hello::Hello() {
	type = MSG_TYPE_HELLO;
}

Hello::Hello(uint8_t version) {
	type = MSG_TYPE_HELLO;

	this->version = version;
}

void Hello::do_send(boost::asio::ip::tcp::socket& socket) {
	write(socket, version);
}

void Hello::recv(boost::asio::ip::tcp::socket& socket) {
	read(socket, version);
}

uint8_t Hello::get_version() {
	return version;
}

/* Pos */

Pos::Pos() {
	type = MSG_TYPE_POS;
}

Pos::Pos(Vector3 pos) {
	type = MSG_TYPE_POS;

	this->id = 0;
	this->pos = pos;
}

Pos::Pos(uint32_t id, Vector3 pos) {
	type = MSG_TYPE_POS;

	this->id = id;
	this->pos = pos;
}

void Pos::do_send(boost::asio::ip::tcp::socket& socket) {
	write(socket, id);
	write(socket, pos);
}

void Pos::recv(boost::asio::ip::tcp::socket& socket) {
	read(socket, id);
	read(socket, pos);
}

uint32_t Pos::get_id() {
	return id;
}

Vector3 Pos::get_pos() {
	return pos;
}

/* Chunk */

Chunk::Chunk() {
	type = MSG_TYPE_CHUNK;
}

Chunk::Chunk(int64_t x, int64_t y) {
	type = MSG_TYPE_CHUNK;

	this->x = x;
	this->y = y;
}

// TODO: move this elsewhere
const int chunk_size = 32;
const int chunk_size_total = chunk_size + 3;

void Chunk::do_send(boost::asio::ip::tcp::socket& socket) {
	write(socket, x);
	write(socket, y);

	boost::asio::write(socket, boost::asio::buffer(data, sizeof(float)*chunk_size_total*chunk_size_total));
}

void Chunk::recv(boost::asio::ip::tcp::socket& socket) {
	read(socket, x);
	read(socket, y);

	// do not free, caller takes ownership
	data = new float[chunk_size_total*chunk_size_total];
	boost::asio::read(socket, boost::asio::buffer(data, sizeof(float)*chunk_size_total*chunk_size_total));
}

void Chunk::set_data(float *data) {
	// caller owns data
	this->data = data;
}

float* Chunk::get_data() {
	return data;
}

void Chunk::get_coords(int64_t& x, int64_t& y) {
	x = this->x;
	y = this->y;
}

/* Message */

Message::Message() {
	type = MSG_TYPE_MSG;
}

Message::Message(std::string msg) {
	type = MSG_TYPE_MSG;

	this->msg = msg;
}

void Message::do_send(boost::asio::ip::tcp::socket& socket) {
	write_string(socket, msg);
}

void Message::recv(boost::asio::ip::tcp::socket& socket) {
	msg = read_string(socket);
}

std::string Message::get_str() {
	return msg;
}

/* Player */

Player::Player() {
	type = MSG_TYPE_PLAYER;
}

Player::Player(uint32_t id, Vector3 pos, std::string name) {
	type = MSG_TYPE_PLAYER;

	this->id = id;
	this->pos = pos;
	this->name = name;
}

void Player::do_send(boost::asio::ip::tcp::socket& socket) {
	write(socket, id);
	write(socket, pos);
	write_string(socket, name);
}

void Player::recv(boost::asio::ip::tcp::socket& socket) {
	read(socket, id);
	read(socket, pos);
	name = read_string(socket);
}

uint32_t Player::get_id() {
	return id;
}

Vector3 Player::get_pos() {
	return pos;
}

std::string Player::get_name() {
	return name;
}

/* Object */

Object::Object() {
	type = MSG_TYPE_OBJECT;
}

Object::Object(uint32_t obj_type, Vector3 pos) {
	type = MSG_TYPE_OBJECT;

	this->obj_type = obj_type;
	this->pos = pos;
}

void Object::do_send(boost::asio::ip::tcp::socket& socket) {
	write(socket, obj_type);
	write(socket, pos);
}

void Object::recv(boost::asio::ip::tcp::socket& socket) {
	read(socket, obj_type);
	read(socket, pos);
}

uint32_t Object::get_type() {
	return obj_type;
}

Vector3 Object::get_pos() {
	return pos;
}