/*
   core/zone.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_ZONE_H__
#define __INCLUDED_CORE_ZONE_H__

#include <string>
#include <list>
#include <map>

namespace core
{

class Zone;

}

#include "core/entity.h"
#include "core/physics.h"

namespace core
{

/// a Zone contains a compartment of the game universe
class Zone : public Label
{
public:
	/// type definition for the content of a zone
	typedef std::list<Entity *> Content;

	/// type definition for the zone registry
	typedef std::map<unsigned int, Zone *> Registry;

	/* ---- static functions ----------------------------------- */

	/// add a zone to the zone registry
	static void add(Zone *zone);

	/// add a zone with a specific id to the registry
	static void add(Zone *zone, unsigned int id);

	/// find a zone in the zone registry
	static Zone *find(unsigned int id);

	/// find a zone in the zone registry
	static Zone *find(std::string const & name);

	/// remove a zone from the zone registry
	static void remove(Zone *zone);

	/// list the zone registry
	static void list();

	/// search the zone registry for an id, label or name
	static Zone *search(std::string const & searchname);

	/// clear the zone registry
	static void clear();

	/// the zone registry
	static inline Registry & registry() {
		return zone_registry;
	}

	/* ---- Zone class ----------------------------------------- */

	/// create a new zone
	Zone(std::string const & label);

	/// create a zone from stream data
	Zone(std::istream & is);

	/// delete a zone
	virtual ~Zone();

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

	/// print the content of a zone
	void print();

	/// zone id
	inline unsigned int id() const {
		return zone_id;
	}

	/// name of the skybox
	inline std::string const & sky() const {
		return zone_sky;
	}

	/// default zone view
	inline Entity *default_view() {
		return zone_defaultview;
	}

	/// find an entity inside a zone
	Entity *find_entity(Entity *entity);

	/// find an entity inside a zone
	Entity *find_entity(unsigned int id);

	/// find a labeled entity inside a zone
	Entity *find_entity(const std::string & label);

	/// search for an entity inside a zone
	Entity *search_entity(const std::string & label);

	/* ---- mutators ------------------------------------------- */

	/// set the skybox name
	inline void set_sky(std::string const & sky) {
		zone_sky.assign(sky);
	}

	///set the default view
	inline void set_default_view(Entity *entity) {
		zone_defaultview = entity;
	}

	/* ---- serializers ---------------------------------------- */

	/// serialize a server-to-client update on a stream
	void serialize_server_update(std::ostream & os) const;

	/// receive a server-to-client update from a stream
	void receive_server_update(std::istream &is);

	/* ---- zone content --------------------------------------- */

	/// the entities belonging to this zone
	inline Content & content() {
		return zone_content;
	}

	/// add an entity to this zone
	void add(Entity *entity);

	/// remove an entity from this zone
	void remove(Entity *entity);

	/// physics world for this zone
	inline btDiscreteDynamicsWorld *physics() {
		return zone_bullet_world;
	}
	
	/// physics vehicle raycaster
	inline btVehicleRaycaster *raycaster() {
		return zone_bullet_raycaster;
	}
	
	math::BoundingBox3f & keepalive_box() {
		return zone_keepalive_box;
	}
	
	const bool keepalive_run() const {
		return zone_keepalive_run;
	}

	void set_keepalive_run(const bool keepalive_run) {
		zone_keepalive_run = keepalive_run;
	}
	
private:
	unsigned int		zone_id;

	std::string		zone_sky;

	Content			zone_content;
	static Registry		zone_registry;

	Entity			*zone_defaultview;
	
	btAxisSweep3		*zone_bullet_cache;
	btDiscreteDynamicsWorld *zone_bullet_world;
	btVehicleRaycaster	*zone_bullet_raycaster;
	
	math::BoundingBox3f	zone_keepalive_box;
	bool			zone_keepalive_run;
};

}

#endif // __INCLUDED_CORE_ZONE_H__