// This file requires 182 MB to compile (optimizing).

// Copyright (c) 2003, 2004 by Jonathan Brandmeyer and others.
// See the file license.txt for complete license terms.
// See the file authors.txt for a complete list of contributors.

#include "display_kernel.hpp"
// Apparently check gets defined somewhere in including display.hpp
#include "mouseobject.hpp"
#include "util/errors.hpp"
#include "python/gil.hpp"
#include <boost/bind.hpp>
#include <boost/python/class.hpp>
#include <boost/python/call_method.hpp>
#include <boost/python/to_python_converter.hpp>
#include <boost/python/overloads.hpp>
#include <boost/python/args.hpp>
#include <boost/python/list.hpp>
#include <boost/python/make_function.hpp>
#include <boost/python/def.hpp>
#include <boost/python/manage_new_object.hpp>

// Must include display.hpp late because on the Mac it includes Carbon.h
// which defines "check" which causes trouble in boost/python/extract.hpp
#include "display.hpp"

namespace cvisual {

// The callback function that is invoked from the display class when
// shutting-down. Prior to Jan. 23, 2008, force_py_exit locked and posted
// a callback to exit, but this failed if the program was sitting
// at scene.mouse.getclick(). Simply calling exit directly seems
// to work fine.
static void
force_py_exit(void)
{
	python::gil_lock gil;
	VPYTHON_NOTE("Exiting");
	std::exit(0);
}

namespace py = boost::python;

template < class Seq >
struct container_to_tuple
{
	static PyObject* convert( const Seq& items)
	{
		PyObject* p = PyTuple_New( items.size() );
		int index = 0;
		for( typename Seq::const_iterator item = items.begin(); item != items.end(); ++item, ++index ) {
			py::object o( *item );
			Py_INCREF(o.ptr());
			PyTuple_SET_ITEM(p, index, o.ptr());
		}
		return p;
	}
};

// I must not know how to use Boost.Python yet, because I need this:
class py_base_display_kernel : public display_kernel {};

// A display implemented in python (e.g. to use PyOpenGL or PyObjC)
class py_display_kernel : public py_base_display_kernel
{
 public:
	PyObject* self;

	py_display_kernel( PyObject* self ) : self(self) {}

	// Delegates key display_kernel virtual methods to Python
	virtual void activate( bool active ) { boost::python::call_method<void>( self, "_activate", active ); }
	virtual EXTENSION_FUNCTION getProcAddress( const char* name ) { return (EXTENSION_FUNCTION)boost::python::call_method<intptr_t>( self, "_getProcAddress", name ); }
	intptr_t base_getProcAddress( const char* name ) { return (intptr_t)display_kernel::getProcAddress(name); }

	// Utility methods for Python subclasses
	bool report_mouse_state(py::object is_button_down,
							int cursor_client_x, int cursor_client_y,
							py::object shift_state,
							bool can_lock_mouse )
	{
		int button_len = boost::python::len( is_button_down );
		boost::scoped_array<bool> buttons( new bool[button_len] );
		for(int b = 0; b<button_len; b++)
			buttons[b] = boost::python::extract<bool>( is_button_down[b] );

		int shift_len = boost::python::len( shift_state );
		boost::scoped_array<bool> shift( new bool[shift_len] );
		for(int b=0; b<shift_len; b++)
			shift[b] = boost::python::extract<bool>( shift_state[b] );

		mouse.report_mouse_state( button_len, &buttons[0],
								  cursor_client_x, cursor_client_y,
								  shift_len, &shift[0],
								  can_lock_mouse );

		return mouse.is_mouse_locked();
	}
};

namespace {

boost::python::object
get_buttons( const mousebase* This)
{
	std::string* ret = This->get_buttons();
	if (ret) {
		boost::python::object py_ret( *ret);
		delete ret;
		return py_ret;
	}
	else {
		return boost::python::object();
	}
}

template <bool (mousebase:: *f)(void) const>
boost::python::object
test_state( const mousebase* This)
{
	if ((This->*f)()) {
		return get_buttons(This);
	}
	else
		return boost::python::object();
}

using namespace boost::python;
BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS( pick_overloads, display_kernel::pick,
	2, 3)
BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS( mousebase_project_partial_overloads,
	mousebase::project2, 1, 2)
} // !namespace (unnamed)

void
wrap_display_kernel(void)
{
	using boost::noncopyable;

	py::class_<display_kernel, noncopyable>( "_display_kernel", no_init)
		// Functions for the internal use of renderable and light classes.
		.def( "add_renderable", &display_kernel::add_renderable)
		.def( "remove_renderable", &display_kernel::remove_renderable)
		.add_property( "up",
			py::make_function( &display_kernel::get_up,
				py::return_internal_reference<>()),
			&display_kernel::set_up)
		.add_property( "forward",
			py::make_function( &display_kernel::get_forward,
				py::return_internal_reference<>()),
			&display_kernel::set_forward)
		.add_property( "scale",	&display_kernel::get_scale,
			&display_kernel::set_scale)
		.add_property( "center",
			py::make_function( &display_kernel::get_center,
				py::return_internal_reference<>()),
			&display_kernel::set_center)
		.add_property( "fov", &display_kernel::get_fov, &display_kernel::set_fov)
		.add_property( "stereodepth", &display_kernel::get_stereodepth, &display_kernel::set_stereodepth)
		.add_property( "lod", &display_kernel::get_lod, &display_kernel::set_lod)
		.add_property( "uniform", &display_kernel::is_uniform,
		 	&display_kernel::set_uniform)
		.add_property( "background", &display_kernel::get_background,
			&display_kernel::set_background)
		.add_property( "foreground", &display_kernel::get_foreground,
			&display_kernel::set_foreground)
		.add_property( "autoscale", &display_kernel::get_autoscale,
			&display_kernel::set_autoscale)
		.add_property( "autocenter", &display_kernel::get_autocenter,
			&display_kernel::set_autocenter)
		.add_property( "stereo", &display_kernel::get_stereomode,
			&display_kernel::set_stereomode)
		.add_property( "show_rendertime",
			&display_kernel::is_showing_rendertime,
			&display_kernel::set_show_rendertime)
		.add_property( "userspin", &display_kernel::spin_is_allowed,
			&display_kernel::allow_spin)
		.add_property( "userzoom", &display_kernel::zoom_is_allowed,
			&display_kernel::allow_zoom)
		.def( "info", &display_kernel::info)
		.add_property( "x", &display_kernel::get_x, &display_kernel::set_x)
		.add_property( "y", &display_kernel::get_y, &display_kernel::set_y)
		.add_property( "width", &display_kernel::get_width, &display_kernel::set_width)
		.add_property( "height", &display_kernel::get_height, &display_kernel::set_height)
		.add_property( "title", &display_kernel::get_title, &display_kernel::set_title)
		.add_property( "fullscreen", &display_kernel::is_fullscreen,
			&display_kernel::set_fullscreen)
		// Omit toolbar for now; not yet available on Windows or Mac
		//.add_property( "toolbar", &display_kernel::is_showing_toolbar,
		//	&display_kernel::set_show_toolbar)
		.add_property( "visible", &display_kernel::get_visible, &display_kernel::set_visible)
		.add_property( "exit", &display_kernel::get_exit, &display_kernel::set_exit)
		.add_property( "cursor", py::make_function(
			&display_kernel::get_cursor, py::return_internal_reference<>()))
		.add_property( "kb", py::make_function(
			&display_kernel::get_kb, py::return_internal_reference<>()))
		.add_property( "mouse", py::make_function(
			&display_kernel::get_mouse, py::return_internal_reference<>()))
		.def( "set_selected", &display_kernel::set_selected)
		.staticmethod( "set_selected")
		.def( "get_selected", &display_kernel::get_selected)
		.staticmethod( "get_selected")

		.def( "_set_ambient", &display_kernel::set_ambient_f)
		.def( "_set_ambient", &display_kernel::set_ambient)
		.def( "_get_ambient", &display_kernel::get_ambient)

		.def( "_set_range", &display_kernel::set_range_d)
		.def( "_set_range", &display_kernel::set_range)
		.def( "_get_range", &display_kernel::get_range)

		.def( "_get_objects", &display_kernel::get_objects)

		.def_readwrite( "enable_shaders", &display_kernel::enable_shaders)
		;

	class_<py_base_display_kernel, py_display_kernel, bases<display_kernel>, noncopyable>
			( "display_kernel")
		// Default implementations of key override methods
		.def( "_getProcAddress", &py_display_kernel::base_getProcAddress )
		// Functions for extending this type in Python.
		.def( "render_scene", &display_kernel::render_scene )
		.def( "report_window_resize", &display_kernel::report_window_resize )
		.def( "report_view_resize", &display_kernel::report_view_resize )
		.def( "report_mouse_state", &py_display_kernel::report_mouse_state )
		.def( "report_closed", &display_kernel::report_closed )
		.def( "pick", &display_kernel::pick, pick_overloads(
			py::args( "x", "y", "pixels")))
		;

	typedef atomic_queue<std::string> kb_object;
	py::class_< kb_object, noncopyable>( "kb_object", no_init)
		.def( "getkey", &kb_object::py_pop, "Returns the next key press value.")
		.add_property( "keys", &kb_object::size)
		;

	py::class_< cursor_object, noncopyable>( "cursor_object", no_init)
		.add_property( "visible", &cursor_object::get_visible, &cursor_object::set_visible)
		;

	py::class_<display, bases<display_kernel>, noncopyable>( "display")
		;

	py::def( "_set_dataroot", &display::set_dataroot);

	py::to_python_converter<
		std::vector<shared_ptr<renderable> >,
		container_to_tuple< std::vector<shared_ptr<renderable> > > >();

	// Free functions for exiting the system.
	// These are undocumented at the moment, and are only used internally.
	def( "waitclose", &display_kernel::waitWhileAnyDisplayVisible,
		"Blocks until all of the Displays are closed by the user.");

	gui_main::on_shutdown.connect( &force_py_exit );

	class_<mousebase>( "clickbase", no_init)
		.def( "project", &mousebase::project2,
			mousebase_project_partial_overloads( args("normal", "point")))
		.def( "project", &mousebase::project1, args("normal", "d"),
			"project the mouse pointer to the plane specified by the normal "
			"vector 'normal' that is either:\n-'d' distance away from the origin"
			" ( click.project( normal=vector, d=scalar)), or\n-includes the "
			"point 'point' ( click.project( normal=vector, point=vector))\n"
			"or passes through the origin ( click.project( normal=vector)).")
		.add_property( "pos", &mousebase::get_pos)
		.add_property( "pick", &mousebase::get_pick)
		.add_property( "pickpos", &mousebase::get_pickpos)
		.add_property( "camera", &mousebase::get_camera)
		.add_property( "ray", &mousebase::get_ray)
		.add_property( "button", &get_buttons)
		.add_property( "press", &test_state<&mousebase::is_press>)
		.add_property( "release", &test_state<&mousebase::is_release>)
		.add_property( "click", &test_state<&mousebase::is_click>)
		.add_property( "drag", &test_state<&mousebase::is_drag>)
		.add_property( "drop", &test_state<&mousebase::is_drop>)
		.add_property( "shift", &mousebase::is_shift)
		.add_property( "alt", &mousebase::is_alt)
		.add_property( "ctrl", &mousebase::is_ctrl)
		;


	class_< event, boost::shared_ptr<event>, bases<mousebase>, noncopyable>
		( "click_object", "An event generated from mouse actions.", no_init)
		;

	class_< mouse_t, boost::shared_ptr<mouse_t>, bases<mousebase>, noncopyable>
		( "mouse_object", "This class provides access to the mouse.", no_init)
		.def( "getclick", &mouse_t::pop_click)
		.add_property( "clicked", &mouse_t::num_clicks)
		.def( "getevent", &mouse_t::pop_event)
		.add_property( "events", &mouse_t::num_events, &mouse_t::clear_events)
		;

}

} // !namespace cvisual;