/*

* Copyright (C) 2013 Alec Thomas <alec@swapoff.org>

* All rights reserved.

*

* This software is licensed as described in the file COPYING, which

* you should have received as part of this distribution.

*

* Author: Alec Thomas <alec@swapoff.org>

*/

#pragma once

// http://docs.python.org/2/extending/extending.html

#include <boost/python.hpp>

#include <boost/function.hpp>

#include <list>

#include <vector>

#include <string>

#include "entityx/System.h"

#include "entityx/Entity.h"

#include "entityx/Event.h"

namespace entityx {

namespace python {

/**

* An EntityX component that represents a Python script.

*/

class PythonScript {

public:

/**

* Create a new PythonScript from a Python Entity class.

*

* @param module The Python module where the Entity subclass resides.

* @param cls The Class within the module. Must inherit from entityx.Entity.

* @param args The *args to pass to the Python constructor.

*/

template <typename ...Args>

PythonScript(const std::string &module, const std::string &cls, Args ... args) : module(module), cls(cls) {

unpack_args(args...);

}

/**

* Create a new PythonScript from an existing Python instance.

*/

explicit PythonScript(boost::python::object object) : object(object) {}

boost::python::object object;

boost::python::list args;

const std::string module, cls;

private:

template <typename A, typename ...Args>

void unpack_args(A &arg, Args ... remainder) {

args.append(arg);

unpack_args(remainder...);

}

void unpack_args() {}

};

class PythonSystem;

/**

* Proxies C++ EntityX events to Python entities.

*/

class PythonEventProxy {

public:

friend class PythonSystem;

/**

* Construct a new event proxy.

*

* @param handler_name The default implementation of can_send() tests for

* the existence of this attribute on an Entity.

*/

explicit PythonEventProxy(const std::string &handler_name) : handler_name(handler_name) {}

virtual ~PythonEventProxy() {}

/**

* Return true if this event can be sent to the provided Python entity.

*

* @param object The Python entity to test for event delivery.

*/

virtual bool can_send(const boost::python::object &object) const {

return PyObject_HasAttrString(object.ptr(), handler_name.c_str());

}

protected:

std::list<Entity> entities;

const std::string handler_name;

private:

/**

* Add an Entity receiver to this proxy. This is called automatically by PythonSystem.

*

* @param entity The entity that will receive events.

*/

void add_receiver(Entity entity) {

entities.push_back(entity);

}

/**

* Delete an Entity receiver. This is called automatically by PythonSystem.

*

* @param entity The entity that was receiving events.

*/

void delete_receiver(Entity entity) {

for ( auto i = entities.begin(); i != entities.end(); ++i ) {

if ( entity == *i ) {

entities.erase(i);

break;

}

}

}

};

/**

* A helper function for class_ to assign a component to an entity.

*/

template <typename Component>

void assign_to(Component& component, EntityManager& entity_manager, Entity::Id id) {

entity_manager.assign<Component>(id, component);

}

/**

* A helper function for retrieving an existing component associated with an

* entity.

*/

template <typename Component>

static Component* get_component(EntityManager& em, Entity::Id id) {

auto handle = em.component<Component>(id);

if ( !handle )

return NULL;

return handle.get();

}

/**

* A PythonEventProxy that broadcasts events to all entities with a matching

* handler method.

*/

template <typename Event>

class BroadcastPythonEventProxy : public PythonEventProxy, public Receiver<BroadcastPythonEventProxy<Event>> {

public:

BroadcastPythonEventProxy(const std::string &handler_name) : PythonEventProxy(handler_name) {}

virtual ~BroadcastPythonEventProxy() {}

void receive(const Event &event) {

for ( auto entity : entities ) {

auto py_entity = entity.template component<PythonScript>();

py_entity->object.attr(handler_name.c_str())(event);

}

}

};

/**

* An entityx::System that bridges EntityX and Python.

*

* This system handles exposing entityx functionality to Python. The Python

* support differs in design from the C++ design in the following ways:

*

* - Entities contain logic and can receive events.

* - Systems and Components can not be implemented in Python.

*/

class PythonSystem : public entityx::System<PythonSystem>, public entityx::Receiver<PythonSystem> {

public:

typedef std::function<void(const std::string &)> LoggerFunction;

PythonSystem(EntityManager& entity_manager); // NOLINT

virtual ~PythonSystem();

/**

* Add system-installed entityx Python path to the interpreter.

*/

void add_installed_library_path();

/**

* Add a Python path to the interpreter.

*/

void add_path(const std::string &path);

/**

* Add a sequence of paths to the interpreter.

*/

template <typename T>

void add_paths(const T &paths) {

for ( auto path : paths ) {

add_path(path);

}

}

/// Return the Python paths the system is configured with.

const std::vector<std::string> &python_paths() const {

return python_paths_;

}

virtual void configure(EventManager& event_manager) override;

virtual void update(EntityManager& entities, EventManager& event_manager, TimeDelta dt) override;

/**

* Set line-based (not including \n) logger for stdout and stderr.

*/

void log_to(LoggerFunction sout, LoggerFunction serr);

/**

* Proxy events of type Event to any Python entity with a handler_name method.

*/

template <typename Event>

void add_event_proxy(EventManager& event_manager, const std::string &handler_name) {

std::shared_ptr<BroadcastPythonEventProxy<Event>> proxy(new BroadcastPythonEventProxy<Event>(handler_name));

event_manager.subscribe<Event>(*proxy.get());

event_proxies_.push_back(std::static_pointer_cast<PythonEventProxy>(proxy));

}

/**

* Proxy events of type Event using the given PythonEventProxy implementation.

*/

template <typename Event, typename Proxy>

void add_event_proxy(EventManager& event_manager, std::shared_ptr<Proxy> proxy) {

event_manager.subscribe<Event>(*proxy);

event_proxies_.push_back(std::static_pointer_cast<PythonEventProxy>(proxy));

}

void receive(const EntityDestroyedEvent &event);

void receive(const ComponentAddedEvent<PythonScript> &event);

private:

void initialize_python_module();

EntityManager& em_;

std::vector<std::string> python_paths_;

LoggerFunction stdout_, stderr_;

static bool initialized_;

std::vector<std::shared_ptr<PythonEventProxy>> event_proxies_;

};

} // namespace python

} // namespace entityx