#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 <stdint.h>
#include <vector>
#include <string>

#include "action.h"
#include "tile.h"
#include "state.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) : type(t) {}
			virtual ~Base() {}
			
		public:
			const Type type;
	};
	
	class Hello : public Base {
		public:
			typedef boost::shared_ptr<Hello> p;
			
			Hello(const std::string& v = "") : Base(Types::Hello), version(v) {}
			
			std::string version;
			
			template<class Archive>
			void serialize(Archive & ar, const unsigned int v) {
				ar & version;
			}
	};
	
	class Login : public Base {
		public:
			typedef boost::shared_ptr<Login> p;
			
			Login(const std::string& n = "") : Base(Types::Login), nick(n) {}
			
			std::string nick;
			
			template<class Archive>
			void serialize(Archive & ar, const unsigned int v) {
				ar & nick;
			}
	};
	
	class LoginResponse : public Base {
		public:
			typedef boost::shared_ptr<LoginResponse> p;
			
			LoginResponse(bool ok = false) : Base(Types::LoginResponse), login_ok(ok) {}
			
			bool login_ok;
			
			template<class Archive>
			void serialize(Archive & ar, const unsigned int v) {
				ar & login_ok;
			}
	};
	
	class LobbyStatus : public Base {
		public:
			typedef boost::shared_ptr<LobbyStatus> p;
			
			LobbyStatus() : Base(Types::LobbyStatus) {}
			
			std::vector<std::string> game_modes;
			
			template<class Archive>
			void serialize(Archive & ar, const unsigned int v) {
				ar & game_modes;
			}
	};
	
	class LobbyAction : public Base {
		public:
			typedef boost::shared_ptr<LobbyAction> p;
			
			LobbyAction(int i = 0) : Base(Types::LobbyAction), index(i) {}
			
			int index;
			
			template<class Archive>
			void serialize(Archive & ar, const unsigned int v) {
				ar & index;
			}
	};
	
	class GameStart : public Base {
		public:
			typedef boost::shared_ptr<GameStart> p;
			
			GameStart() : Base(Types::GameStart) {}
			
			std::vector<std::string> players;
			int player_id;
			
			template<class Archive>
			void serialize(Archive & ar, const unsigned int v) {
				ar & players;
				ar & player_id;
			}
	};
	
	class Ready : public Base {
		public:
			typedef boost::shared_ptr<Ready> p;
			
			Ready() : Base(Types::Ready) {}
			
			template<class Archive>
			void serialize(Archive & ar, const unsigned int v) {
				
			}
	};
	
	class RoundStart : public Base {
		public:
			typedef boost::shared_ptr<RoundStart> p;
			
			RoundStart() : Base(Types::RoundStart) {}
			
			template<class Archive>
			void serialize(Archive & ar, const unsigned int v) {
				
			}
	};
	
	class RoundState : public Base {
		public:
			typedef boost::shared_ptr<RoundState> p;
			
			RoundState() : Base(Types::RoundState) {}
			RoundState(const PlayerState& pl_d, const PlayerState& pl_r, const PlayerState& pl_u, const PlayerState& pl_l, const GameState& g, const Actions& a)
			: Base(Types::RoundState), game(g), possible_actions(a) {
				players[0] = pl_d;
				players[1] = pl_r;
				players[2] = pl_u;
				players[3] = pl_l;
			}
			
			//! Player states.
			PlayerState players[4];
			
			//! Game state.
			GameState game;
			
			//! List of actions client must return one of.
			Actions possible_actions;
			
			template<class Archive>
			void serialize(Archive & ar, const unsigned int v) {
				ar & players;
				ar & game;
				ar & possible_actions;
			}
	};
	
	class RoundAction : public Base {
		public:
			typedef boost::shared_ptr<RoundAction> p;
			
			RoundAction() : Base(Types::RoundAction) {}
			
			Action action;
			
			template<class Archive>
			void serialize(Archive & ar, const unsigned int v) {
				ar & action;
			}
	};
	
	class RoundEnd : public Base {
		public:
			typedef boost::shared_ptr<RoundEnd> p;
			
			RoundEnd() : Base(Types::RoundEnd) {}
			
			template<class Archive>
			void serialize(Archive & ar, const unsigned int v) {
				
			}
	};
	
	typedef boost::shared_ptr<Base> p;
};

#endif