/*
   core/gameinterface.h
   This file is part of the Osirion project and is distributed under
   the terms of the GNU General Public License version 2
*/

#ifndef __INCLUDED_CORE_GAMEINTERFACE_H__
#define __INCLUDED_CORE_GAMEINTERFACE_H__

#include "core/player.h"
#include "core/info.h"
#include "core/inventory.h"
#include "model/vertexarray.h"

namespace core
{

/// abstract interface from the core to the game-specific code
class GameInterface
{
public:
	/// create a new game
	GameInterface();

	/// destroy the game
	virtual ~GameInterface();

	/// type definition for the Players collection
	typedef std::list<Player *> Players;

	/*----- inspectors ---------------------------------------------- */

	/// return the local player
	inline Player *localplayer() {
		return &game_localplayer;
	}

	inline Players & players() {
		return game_players;
	}
	
	inline const unsigned long playerlist_timestamp() const {
		return game_playerlist_timestamp;
	}

	inline model::VertexArray *vertexarray() {
		return game_vertexarray;
	}

	/// find the first player who's id or name matches the search string
	Player *find_player(const std::string &search);
	
	/// find a player id
	Player *find_player(const int playerid);
	
	/// find a player
	Player *find_player(const Player *player);

	/// show a list of connected players
	void list_players();

	/// returns true if the game server can run a time frime
	inline bool running() const {
		return game_running;
	}
	
	inline bool error() const {
		return !game_running;
	}

	/// returns true if the game is running an interactive module
	inline bool interactive() const {
		return game_interactive;
	}

	/**
	 * @brief return the current game time, in seconds.
	 * */
	inline float time() const {
		return (float) game_timestamp / 1000.0f;
	}
	
	/**
	 * @brief return the current game time, in milliseconds.
	 * 1000 milliseconds equals one second.
	 */
	inline unsigned long timestamp() const {
		return game_timestamp;
	}
	
	/*----- virtual inspectors --------------------------------------- */
	
	/// request info record with id 
	virtual Info *request_info(const unsigned int id) = 0;
	
	/// request inventory for entity with id
	virtual Inventory *request_inventory(Entity *entity)  = 0;
	
	/*-----  mutators ------------------------------------------------- */

	/// clear all game variables, game functions and entities
	void clear();

	void set_playerlist_timestamp(const unsigned long timestamp);
	
	virtual void abort();
	
	/// run one game time frame
	/// @param timestamp current application time
	virtual void frame(const unsigned long timestamp) = 0;

protected:
	/// the local player
	static Player 			game_localplayer;

	/// all the players
	Players				game_players;

	/// timestamp of the time the playerlist was last changed
	unsigned long			game_playerlist_timestamp;
	
	/// set the current game time
	void set_timestamp(const unsigned long timestamp);
	
	void set_running(const bool running);
	
	void set_interactive(const bool interactive);

	model::VertexArray 		*game_vertexarray;
	
private:
	bool				game_running;
	bool				game_interactive;
	
	unsigned long			game_timestamp;
};

/// global local player instance
Player *localplayer();

/// global local control instance
EntityControlable *localcontrol();

}

#endif // __INCLUDED_CORE_GAMEINTERFACE_H__