#include "message.h"

#include <boost/serialization/vector.hpp>
#include <boost/serialization/string.hpp>
#include <boost/serialization/shared_ptr.hpp>

#include <cstring>
#include <sstream>

Message::Base::Base(Type t) : type(t) {
	
}

Message::NullBase::NullBase(Type t) : Base(t) {
	
}

std::pair<uint8_t*, std::size_t> Message::NullBase::serialize() {
	return std::pair<uint8_t*, std::size_t>(0, 0);
}

void Message::NullBase::deserialize(uint8_t* data, std::size_t bytes) {
	
}

Message::BoostBase::BoostBase(Type t) : Base(t) {
	
}

std::pair<uint8_t*, std::size_t> Message::BoostBase::serialize() {
	std::ostringstream os;
	boost::archive::text_oarchive oa(os);
	
	serialize(oa);
	
	std::size_t s = os.str().size();
	uint8_t* buf = new uint8_t[s];
	
	memcpy(buf, os.str().c_str(), s);
	
	return std::pair<uint8_t*, std::size_t>(buf, s);
}

void Message::BoostBase::deserialize(uint8_t* data, std::size_t bytes) {
	std::istringstream is(std::string((char*)data, bytes));
	boost::archive::text_iarchive ia(is);
	
	deserialize(ia);
}

Message::Hello::Hello() : Base(Types::Hello) {
	
}

Message::Hello::Hello(const std::string& v) : Base(Types::Hello), version(v) {
	
}

std::pair<uint8_t*, std::size_t> Message::Hello::serialize() {
	std::size_t s = version.size();
	uint8_t* buf = new uint8_t[s];
	
	memcpy(buf, version.c_str(), version.size());
	
	return std::pair<uint8_t*, std::size_t>(buf, s);
}

void Message::Hello::deserialize(uint8_t* data, std::size_t bytes) {
	version = std::string((char*)data, bytes);
}

Message::Login::Login() : Base(Types::Login) {
	
}

Message::Login::Login(const std::string& n) : Base(Types::Login), nick(n) {
	
}

std::pair<uint8_t*, std::size_t> Message::Login::serialize() {
	std::size_t s = nick.size();
	uint8_t* buf = new uint8_t[s];
	
	memcpy(buf, nick.c_str(), nick.size());
	
	return std::pair<uint8_t*, std::size_t>(buf, s);
}

void Message::Login::deserialize(uint8_t* data, std::size_t bytes) {
	nick = std::string((char*)data, bytes);
}

Message::LoginResponse::LoginResponse() : Base(Types::LoginResponse) {

}

Message::LoginResponse::LoginResponse(bool ok) : Base(Types::LoginResponse), login_ok(ok) {
	
}

std::pair<uint8_t*, std::size_t> Message::LoginResponse::serialize() {
	uint8_t* buf = new uint8_t[1];
	
	buf[0] = uint8_t(login_ok);
	
	return std::pair<uint8_t*, std::size_t>(buf, 1);
}

void Message::LoginResponse::deserialize(uint8_t* data, std::size_t bytes) {
	login_ok = bool(data[0]);
}

Message::GameStart::GameStart() : BoostBase(Types::GameStart) {
	
}

void Message::GameStart::serialize(boost::archive::text_oarchive& ar) {
	ar & players;
	ar & player_id;
}

void Message::GameStart::deserialize(boost::archive::text_iarchive& ar) {
	ar & players;
	ar & player_id;
}

Message::Ready::Ready() : NullBase(Types::Ready) {
	
}

Message::RoundStart::RoundStart() : NullBase(Types::RoundStart) {
	
}

Message::RoundState::RoundState() : BoostBase(Types::RoundState) {
	
}

Message::RoundState::RoundState(State state) : BoostBase(Types::RoundState) {
	// Compatibility constructor. To be removed.
	for(std::size_t i = 0; i < 4; i++) {
		hand[i] = state.players[i].hand;
		open[i] = state.players[i].open;
		pond[i] = state.players[i].pond;
		possible_actions = state.possible_actions;
	}
}

void Message::RoundState::serialize(boost::archive::text_oarchive& ar) {
	ar & hand;
	ar & open;
	ar & pond;
	ar & dora;
	ar & possible_actions;
}

void Message::RoundState::deserialize(boost::archive::text_iarchive& ar) {
	ar & hand;
	ar & open;
	ar & pond;
	ar & dora;
	ar & possible_actions;
}

Message::RoundAction::RoundAction() : BoostBase(Types::RoundAction) {
	
}

void Message::RoundAction::serialize(boost::archive::text_oarchive& ar) {
	ar & action;
}

void Message::RoundAction::deserialize(boost::archive::text_iarchive& ar) {
	ar & action;
}

Message::RoundEnd::RoundEnd() : NullBase(Types::RoundEnd) {

}