#ifndef MESSAGE_H
#define MESSAGE_H

#include <boost/shared_ptr.hpp>
#include <boost/make_shared.hpp>
using boost::make_shared;
using boost::dynamic_pointer_cast;

#include <boost/archive/text_oarchive.hpp>
#include <boost/archive/text_iarchive.hpp>

#include <stdint.h>
#include <vector>
#include <string>

#include "action.h"
#include "tile.h"

namespace Message {
	namespace Types {
		//! Message types.
		enum Type {
			Undefined,
			Hello,
			Login,
			LoginResponse,
			LobbyStatus,
			LobbyAction,
			GameStart,
			Ready,
			RoundStart,
			RoundState,
			RoundAction,
			RoundEnd,
			GameEnd
		};
	}
	using Types::Type;
	
	class Base {
		protected:
			Base(Type t);
			
		public:
			const Type type;
			
			virtual std::pair<uint8_t*, std::size_t> serialize() = 0;
			virtual void deserialize(uint8_t* data, std::size_t bytes) = 0;
	};
	
	class NullBase : public Base {
		protected:
			NullBase(Type t);
			
		public:
			virtual std::pair<uint8_t*, std::size_t> serialize();
			virtual void deserialize(uint8_t* data, std::size_t bytes);
	};
	
	class BoostBase : public Base {
		protected:
			BoostBase(Type t);
			
		public:
			virtual std::pair<uint8_t*, std::size_t> serialize();
			virtual void deserialize(uint8_t* data, std::size_t bytes);
			
			virtual void serialize(boost::archive::text_oarchive& ar) = 0;
			virtual void deserialize(boost::archive::text_iarchive& ar) = 0;
	};
	
	class Hello : public Base {
		public:
			typedef boost::shared_ptr<Hello> p;
			
			Hello();
			Hello(const std::string& v);
			
			std::string version;
			
			virtual std::pair<uint8_t*, std::size_t> serialize();
			virtual void deserialize(uint8_t* data, std::size_t bytes);
	};
	
	class Login : public Base {
		public:
			typedef boost::shared_ptr<Login> p;
			
			Login();
			Login(const std::string& n);
			
			std::string nick;
			
			virtual std::pair<uint8_t*, std::size_t> serialize();
			virtual void deserialize(uint8_t* data, std::size_t bytes);
	};
	
	class LoginResponse : public Base {
		public:
			typedef boost::shared_ptr<LoginResponse> p;
			
			LoginResponse();
			LoginResponse(bool ok);
			
			bool login_ok;
			
			virtual std::pair<uint8_t*, std::size_t> serialize();
			virtual void deserialize(uint8_t* data, std::size_t bytes);
	};
	
	class GameStart : public BoostBase {
		public:
			typedef boost::shared_ptr<GameStart> p;
			
			GameStart();
			
			std::vector<std::string> players;
			int player_id;
			
			virtual void serialize(boost::archive::text_oarchive& ar);
			virtual void deserialize(boost::archive::text_iarchive& ar);
	};
	
	class Ready : public NullBase {
		public:
			typedef boost::shared_ptr<Ready> p;
			
			Ready();
	};
	
	class RoundStart : public NullBase {
		public:
			typedef boost::shared_ptr<RoundStart> p;
			
			RoundStart();
	};
	
	class RoundState : public BoostBase {
		public:
			typedef boost::shared_ptr<RoundState> p;
			
			// Player contents.
			struct Player {
				//! Concealed tiles in hand.
				Tiles hand;
				//! Open tiles in hand.
				Tilegroups open;
				//! Discarded tiles.
				Tiles pond;
				
				template<class Archive>
				void serialize(Archive & ar, const unsigned int version) {
					ar & hand;
					ar & open;
					ar & pond;
				}
			};
			
			RoundState();
			RoundState(const Player& pl_d, const Player& pl_r, const Player& pl_u, const Player& pl_l, const Tiles& d, const Actions& a);
			
			Player players[4];
			
			Tiles dora;
			
			Actions possible_actions;
			
			virtual void serialize(boost::archive::text_oarchive& ar);
			virtual void deserialize(boost::archive::text_iarchive& ar);
	};
	
	class RoundAction : public BoostBase {
		public:
			typedef boost::shared_ptr<RoundAction> p;
			
			RoundAction();
			
			Action action;
			
			virtual void serialize(boost::archive::text_oarchive& ar);
			virtual void deserialize(boost::archive::text_iarchive& ar);
	};
	
	class RoundEnd : public NullBase {
		public:
			typedef boost::shared_ptr<RoundEnd> p;
			
			RoundEnd();
	};
	typedef boost::shared_ptr<Base> p;
};

#endif