// This file takes roughly 115 MB RAM to compile.

// Copyright (c) 2000, 2001, 2002, 2003 by David Scherer and others.
// 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 <stdexcept>
#include <exception>
#include <iostream>

#include <boost/python/exception_translator.hpp>
#include <boost/python/module.hpp>
#include <boost/python/numeric.hpp>
#include <boost/python/def.hpp>

#define PY_ARRAY_UNIQUE_SYMBOL visual_PyArrayHandle
//#include <numpy/arrayobject.h>

#include "util/rate.hpp"
#include "util/errors.hpp"
#include "python/num_util.hpp"
#include "python/gil.hpp"

// Python 2/3 compatibility
#ifndef PyString_Check
#define PyString_Check   PyUnicode_Check
#endif

namespace cvisual {
void wrap_display_kernel();
void wrap_primitive();
void wrap_rgba();
void wrap_vector();
void wrap_arrayobjects();

void
translate_std_out_of_range( std::out_of_range e)
{
	PyErr_SetString( PyExc_IndexError, e.what());
}

void
translate_std_invalid_argument( std::invalid_argument e)
{
	PyErr_SetString( PyExc_ValueError, e.what());
}

void
translate_std_runtime_error( std::runtime_error e)
{
	PyErr_SetString( PyExc_RuntimeError, e.what());
}

void
py_rate( double freq)
{
	python::gil_release R;
	rate(freq);
}

namespace py = boost::python;

struct double_from_int
{
	double_from_int()
	{
		py::converter::registry::push_back(
			&convertible,
			&construct,
			py::type_id<double>());
	}

	static void* convertible( PyObject* obj)
	{
		PyObject* newobj = PyNumber_Float(obj);
		if (!PyString_Check(obj) && newobj) {
			Py_DECREF(newobj);
			return obj;
		} else {
			if (newobj) {
				Py_DECREF(newobj);
			}
			PyErr_Clear();
			return 0;
		}
	}

	static void construct(
		PyObject* _obj,
		py::converter::rvalue_from_python_stage1_data* data)
	{
		PyObject* newobj = PyNumber_Float(_obj);
        double* storage = (double*)(
            (py::converter::rvalue_from_python_storage<double>*)
            data)->storage.bytes;
        *storage = py::extract<double>(newobj);
		Py_DECREF(newobj);
		data->convertible = storage;
	}
};

struct float_from_int
{
	float_from_int()
	{
		py::converter::registry::push_back(
			&convertible,
			&construct,
			py::type_id<float>());
	}

	static void* convertible( PyObject* obj)
	{
		PyObject* newobj = PyNumber_Float(obj);
		if (!PyString_Check(obj) && newobj) {
			Py_DECREF(newobj);
			return obj;
		} else {
			if (newobj) {
				Py_DECREF(newobj);
			}
			PyErr_Clear();
			return 0;
		}
	}

	static void construct(
		PyObject* _obj,
		py::converter::rvalue_from_python_stage1_data* data)
	{
		PyObject* newobj = PyNumber_Float(_obj);
        float* storage = (float*)(
            (py::converter::rvalue_from_python_storage<float>*)
            data)->storage.bytes;
        *storage = py::extract<float>(newobj);
		Py_DECREF(newobj);
		data->convertible = storage;
	}
};

BOOST_PYTHON_MODULE( cvisual)
{
	VPYTHON_NOTE( "Importing cvisual from vpython-core2.");

	using namespace boost::python;
	numeric::array::set_module_and_type( "numpy", "ndarray");

#if __GNUG__
#if __GNUC__ == 3
#if __GNUCMINOR__ >= 1 && __GNUCMINOR__ < 4
	std::set_terminate( __gnu_cxx::__verbose_terminate_handler);
#endif
#endif
#endif

	// Initialize the Python thread system.
	PyEval_InitThreads();

	// A subset of the python standard exceptions may be thrown from visual
	register_exception_translator<std::out_of_range>(
		&translate_std_out_of_range);
	register_exception_translator<std::invalid_argument>(
		&translate_std_invalid_argument);
	register_exception_translator<std::runtime_error>(
		&translate_std_runtime_error);

	def( "rate", py_rate, "rate(arg) -> Limits the execution rate of a loop to arg"
		" iterations per second.");

	double_from_int();
	float_from_int();
	wrap_vector();
	wrap_rgba();
	wrap_display_kernel();
	wrap_primitive();
	wrap_arrayobjects();
	python::init_numpy(); // initialize numpy
}

} // !namespace cvisual