#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,
			GameResume,
			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 = "", uint64_t c = 0) : Base(Types::Login), nick(n), cookie(c) {}
			
			std::string nick;
			
			uint64_t cookie;
			
			template<class Archive>
			void serialize(Archive & ar, const unsigned int v) {
				ar & nick;
				ar & cookie;
			}
	};
	
	class LoginResponse : public Base {
		public:
			typedef boost::shared_ptr<LoginResponse> p;
			
			//! Response type.
			enum Type {
				//! Invalid login attempt.
				Invalid,
				//! Login to lobby.
				Lobby,
				//! Login to resume ongoing game.
				Resume
			};
			
			LoginResponse(Type t = Invalid, uint64_t c = 0) : Base(Types::LoginResponse), type(t), cookie(c) {}
			
			Type type;
			
			uint64_t cookie;
			
			template<class Archive>
			void serialize(Archive & ar, const unsigned int v) {
				ar & type;
				ar & cookie;
			}
	};
	
	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;
			
			template<class Archive>
			void serialize(Archive & ar, const unsigned int v) {
				ar & players;
			}
	};
	
	class GameResume : public Base {
		public:
			typedef boost::shared_ptr<GameResume> p;
			
			GameResume() : Base(Types::GameResume) {}
			
			std::vector<std::string> players;
			
			template<class Archive>
			void serialize(Archive & ar, const unsigned int v) {
				ar & players;
			}
	};
	
	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;
			
			struct Score {
				std::string nick;
				int score;
				int won;
				
				template<class Archive>
				void serialize(Archive & ar, const unsigned int v) {
					ar & nick;
					ar & score;
					ar & won;
				}
			};
			
			RoundEnd() : Base(Types::RoundEnd) {}
			Tiles hand;
			std::vector<std::pair<std::string, int> > yakus;
			int total_han;
			int total_fu;
			int won;
			Score score[4];
			
			bool game_end;
			
			template<class Archive>
			void serialize(Archive & ar, const unsigned int v) {
				ar & hand;
				ar & yakus;
				ar & total_han;
				ar & total_fu;
				ar & won;
				ar & score;
				ar & game_end;
			}
	};
	
	class GameEnd : public Base {
		public:
			typedef boost::shared_ptr<GameEnd> p;
			Message::RoundEnd::Score scores[4];
			
			GameEnd() : Base(Types::GameEnd) {}
			
			template<class Archive>
			void serialize(Archive & ar, const unsigned int v) {
				ar & scores;
			}
	
	};
	
	typedef boost::shared_ptr<Base> p;
};

#endif