// -*-c++-*- Copyright (C) 2002-2003 Gideon May (gideon@computer.org)
//
// Permission to copy, use, sell and distribute this software is granted
// provided this copyright notice appears in all copies.
// Permission to modify the code and to distribute modified code is granted
// provided this copyright notice appears in all copies, and a notice
// that the code was modified is included with the copyright notice.
//
// This software is provided "as is" without express or implied warranty,
// and with no claim as to its suitability for any purpose.

#include <boost/python/class.hpp>
#include <boost/python/call_method.hpp>
#include <boost/python/scope.hpp>
#include <boost/python/overloads.hpp>
#include <boost/python/tuple.hpp>
#include <boost/python/return_value_policy.hpp>
#include <boost/utility.hpp>

#include <string.h>

#ifdef __USE_OSX_IMPLEMENTATION__
#include "missing.hpp"
#include <Carbon/Carbon.h>
#include <OpenGL/OpenGL.h>
#include <OpenGL/gl.h>
#undef check
#endif

#include <Producer/Export>
#include <Producer/Types>
#include <Producer/Math>
#include <Producer/Referenced>
#include <Producer/Camera>

#include "producer_ptr.hpp"

using namespace boost::python;

BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(frame_overloads, Producer::Camera::frame, 0, 1);

BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(setRenderSurfaceWindowRectangle_overloads, Producer::Camera::setRenderSurfaceWindowRectangle, 4, 5);

namespace {
class SceneHandler : public Producer::Camera::SceneHandler
{
    public:
        SceneHandler() : _self(NULL) {}
        SceneHandler(PyObject * self) : _self(self) {}
        /** useAutoView() indicates to the Camera whether it should
            set the PROJECTION and MODELVIEW matrices by applying the
            Lens and PositionAndAttitudeMatrix.  Return false, if
            it is intended that the Matrix manipulation occur in a
            local method.  */
        virtual bool useAutoView() { return true; }

        /** Prepare the scene by sorting, and
            ordering for optimal rendering */
        virtual void cull( Producer::Camera &) {}

        /** clears the screen. */
        virtual void clear( Producer::Camera &camera ) { camera.clear(); }

        /** The draw() method must be implemented by
            the derived class for rendering the scene */
        virtual void draw( Producer::Camera &) {};

        /** If implemented, will override all of
            the functionality of the Camera::frame().  Must return
            true if override is the intent. */
        virtual bool frame( Producer::Camera &) { return false;}
    private:
        PyObject * _self;
};

class Callback : public Producer::Camera::Callback
{
    public:
        Callback() : _self(NULL) {}
        Callback(PyObject * self) : _self(self) {}

        void operator()(const Producer::Camera&)
        {
            try {
                call_method<void>(_self, "apply");
            } catch(...) {
                handle_exception();
                PyErr_Print();
                throw_error_already_set();
                return;
            }
        }
    private:
        PyObject * _self;
};


void Camera_addPreCullCallback(Producer::Camera * self, PyObject * cb)
{
    // is_callback is true if the cb is a direct derived class from Producer::Camera::Callback
    // if it is 0, then it's a python defined class
    bool is_callback = extract<Producer::Camera::Callback *>(cb).check();

    Py_XINCREF(cb); // FIXME Memory leak, on node dtor should decref the cb object

    // if it is a c++ class, set the node callback directly
    if (is_callback) {
        extract<Producer::Camera::Callback *> callback(cb);
        self->addPreCullCallback(callback);
    } else {
        Callback * callback = new Callback(cb); // another memory leak, the python object isn't deleted
        self->addPreCullCallback(callback);
    }
}

void Camera_addPostCullCallback(Producer::Camera * self, PyObject * cb)
{
    // is_callback is true if the cb is a direct derived class from Producer::Camera::Callback
    // if it is 0, then it's a python defined class
    bool is_callback = extract<Producer::Camera::Callback *>(cb).check();

    Py_XINCREF(cb); // FIXME Memory leak, on node dtor should decref the cb object

    // if it is a c++ class, set the node callback directly
    if (is_callback) {
        extract<Producer::Camera::Callback *> callback(cb);
        self->addPostCullCallback(callback);
    } else {
        Callback * callback = new Callback(cb); // another memory leak, the python object isn't deleted
        self->addPostCullCallback(callback);
    }
}

void Camera_addPreDrawCallback(Producer::Camera * self, PyObject * cb)
{
    // is_callback is true if the cb is a direct derived class from Producer::Camera::Callback
    // if it is 0, then it's a python defined class
    bool is_callback = extract<Producer::Camera::Callback *>(cb).check();

    Py_XINCREF(cb); // FIXME Memory leak, on node dtor should decref the cb object

    // if it is a c++ class, set the node callback directly
    if (is_callback) {
        extract<Producer::Camera::Callback *> callback(cb);
        self->addPreDrawCallback(callback);
    } else {
        Callback * callback = new Callback(cb); // another memory leak, the python object isn't deleted
        self->addPreDrawCallback(callback);
    }
}

void Camera_addPostDrawCallback(Producer::Camera * self, PyObject * cb)
{
    // is_callback is true if the cb is a direct derived class from Producer::Camera::Callback
    // if it is 0, then it's a python defined class
    bool is_callback = extract<Producer::Camera::Callback *>(cb).check();

    Py_XINCREF(cb); // FIXME Memory leak, on node dtor should decref the cb object

    // if it is a c++ class, set the node callback directly
    if (is_callback) {
        extract<Producer::Camera::Callback *> callback(cb);
        self->addPostDrawCallback(callback);
    } else {
        Callback * callback = new Callback(cb); // another memory leak, the python object isn't deleted
        self->addPostDrawCallback(callback);
    }
}

tuple getProjectionRectangle(Producer::Camera * self)
{
    float left, right, bottom, top;
    self->getProjectionRectangle(left, right, bottom, top );
    return make_tuple(left, right, bottom, top);
}

}

namespace PyProd {
void init_Camera()
{
    class_<Producer::Camera, Producer::ref_ptr<Producer::Camera>, bases<Producer::Referenced>, boost::noncopyable>
        camera("Camera", no_init);

    scope camera_scope(camera);

    camera
        .def(init<>())
        .def("enable",
            &Producer::Camera::enable)
        .def("disable",
            &Producer::Camera::disable)
        .def("isEnabled",
            &Producer::Camera::isEnabled)

        .def("frame",
            &Producer::Camera::frame,
            frame_overloads())

        .def("setSceneHandler",
            &Producer::Camera::setSceneHandler)
        .def("getSceneHandler",
            (Producer::Camera::SceneHandler* (Producer::Camera::*)())
            &Producer::Camera::getSceneHandler,
            return_value_policy<manage_producer_object>())

        .def("setRenderSurface",
            &Producer::Camera::setRenderSurface)

        .def("getRenderSurface",
            (Producer::RenderSurface * (Producer::Camera::*)())
            &Producer::Camera::getRenderSurface,
            return_value_policy<manage_producer_object>())

        .def("setRenderSurfaceWindowRectangle",
            &Producer::Camera::setRenderSurfaceWindowRectangle,
            setRenderSurfaceWindowRectangle_overloads())

        .def("setLens",
            &Producer::Camera::setLens)

        .def("getLens",
            (Producer::Camera::Lens * (Producer::Camera::*)())
            &Producer::Camera::getLens,
            return_internal_reference<>())

        // Convenience methods
        .def("setLensPerspective",
            (void (Producer::Camera::*)( double, double, double, double ))
            &Producer::Camera::setLensPerspective)

        .def("setLensFrustum",
	    (void (Producer::Camera::*)( double, double, double, double, double, double))
            &Producer::Camera::setLensFrustum)

        .def("setLensOrtho",
	    (void (Producer::Camera::*)(double, double, double, double, double, double))
            &Producer::Camera::setLensOrtho)

        .def("setLensShear",
            &Producer::Camera::setLensShear)

        .def("getLensShear",
            &Producer::Camera::getLensShear)

        .def("convertLensToOrtho",
            &Producer::Camera::convertLensToOrtho)

        .def("convertLensToPerspective",
            &Producer::Camera::convertLensToPerspective)

        .def("getLensProjectionType",
            &Producer::Camera::getLensProjectionType)

        .def("applyLens",
            &Producer::Camera::applyLens)

        .def("getLensParams",
            &Producer::Camera::getLensParams)

        .def("getLensHorizontalFov",
            &Producer::Camera::getLensHorizontalFov)

        .def("getLensVerticalFov",
            &Producer::Camera::getLensVerticalFov)

        .def("getLensMatrix",
            &Producer::Camera::getLensMatrix)

        .def("setLensAutoAspect",
            &Producer::Camera::setLensAutoAspect)

        .def("getLensAutoAspect",
            &Producer::Camera::getLensAutoAspect)

        .def("setLensAspectRatio",
            &Producer::Camera::setLensAspectRatio)

        .def("getLensAspectRatio",
            &Producer::Camera::getLensAspectRatio)

        .def("setProjectionRectangle",
            (void (Producer::Camera::*)( const float, const float, const float, const float ))
            &Producer::Camera::setProjectionRectangle)

        .def("setProjectionRectangle",
            (void (Producer::Camera::*)(int, int, unsigned int, unsigned int))
            &Producer::Camera::setProjectionRectangle)

        // void setProjectionRectangle( const float left, const float right, const float bottom, const float top );
        .def("getProjectionRectangle",
            &getProjectionRectangle)
        // What is causing this bug?
        // /usr/include/boost/mpl/if.hpp:75:   instantiated from here /usr/include/boost/python/object/make_instance.hpp:25: error: invalid application of `sizeof' to an incomplete type
        //.def("getProjectionMatrix", &Producer::Camera::getProjectionMatrix, return_internal_reference<>())


        // float *getProjectionMatrix ()
        // eye xyz, center xyz, up vector xyz
        .def("setViewByLookat", (void (Producer::Camera::*)(float, float, float, float, float, float, float, float, float))
                &Producer::Camera::setViewByLookat)

        .def("setViewByLookat", (void (Producer::Camera::*)(const Producer::Vec3 &, const Producer::Vec3 &, const Producer::Vec3 &))
                &Producer::Camera::setViewByLookat)

        // void setViewByLookat( float eyex, float eyey, float eyez, float centerx, float centery, float centerz, float upx, float upy, float upz );
        // void setViewByLookat( const Vec3 &eye, const Vec3 &center, const Vec3 &up );

        .def("setViewByMatrix",
            &Producer::Camera::setViewByMatrix)

        // void setFocalDistance( double focal_distance ) { _focal_distance = focal_distance; }
        // const float *getViewMatrix( void ) const;
        // const float *getPositionAndAttitudeMatrix( void ) const { return _viewMatrix; }
        // void applyView();

        // void setOffset( const float matrix[16], double _xshear=0.0, double _yshear=0.0);

        .def("setOffset",
            (void (Producer::Camera::*)(double, double))
            &Producer::Camera::setOffset)

        .def("setClearColor", &Producer::Camera::setClearColor)
        .def("getClearColor", &Producer::Camera::getClearColor)
        .def("clear", &Producer::Camera::clear)
        .def("advance", &Producer::Camera::advance)
        .def("sync", &Producer::Camera::sync)

        .def("addPreCullCallback",
            &Camera_addPreCullCallback)

        .def("addPostCullCallback",
            &Camera_addPostCullCallback)

        .def("addPreDrawCallback",
            &Camera_addPreDrawCallback)

        .def("addPostDrawCallback",
            &Camera_addPostDrawCallback)
        .def("cancel", &Producer::Camera::cancel)
        .def("run", &Producer::Camera::run)

        .def("setSyncBarrier", &Producer::Camera::setSyncBarrier)
        .def("setFrameBarrier", &Producer::Camera::setFrameBarrier)
        .def("setInitTime", &Producer::Camera::setInitTime)

        //.def("getFrameStats",
        //    &Producer::Camera::getFrameStats, return_internal_reference<>())

        .def("setInstrumentationMode", &Producer::Camera::setInstrumentationMode)
        .def("getInstrumentationMode", &Producer::Camera::getInstrumentationMode)

        .def("setBlockOnVsync", &Producer::Camera::setBlockOnVsync)
        .def("getBlockOnVsync", &Producer::Camera::getBlockOnVsync)


        .def("setIndex", &Producer::Camera::setIndex)
        .def("getIndex", &Producer::Camera::getIndex)

        .def("setShareLens", &Producer::Camera::setShareLens)
        .def("getShareLens", &Producer::Camera::getShareLens)

        .def("setShareView", &Producer::Camera::setShareView)
        .def("getShareView", &Producer::Camera::getShareView)
        ;
    {
        class_<Producer::Camera::SceneHandler, SceneHandler,
            bases<Producer::Referenced>, boost::noncopyable>
            scene_handler("SceneHandler");
    }

    {
        class_<Producer::Camera::Lens, boost::noncopyable> lens("Lens", no_init);
        lens
            .def("setPerspective",
                &Producer::Camera::Lens::setPerspective)
            .def("setFrustum",
                &Producer::Camera::Lens::setFrustum)
            .def("setOrtho",
                &Producer::Camera::Lens::setOrtho)
            .def("convertToOrtho",
                &Producer::Camera::Lens::convertToOrtho)
            .def("convertToPerspective",
                &Producer::Camera::Lens::convertToPerspective)
            .def("apply",
                &Producer::Camera::Lens::apply)
            .def("generateMatrix",
                &Producer::Camera::Lens::generateMatrix)
            .def("getProjectionType",
                &Producer::Camera::Lens::getProjectionType)
            .def("getParams",
                &Producer::Camera::Lens::getParams)
            .def("getHorizontalFov",
                &Producer::Camera::Lens::getHorizontalFov)
            .def("getVerticalFov",
                &Producer::Camera::Lens::getVerticalFov)
            .def("setAutoAspect",
                &Producer::Camera::Lens::setAutoAspect)
            .def("getAutoAspect",
                &Producer::Camera::Lens::getAutoAspect)
            .def("setAspectRatio",
                &Producer::Camera::Lens::setAspectRatio)
            .def("getAspectRatio",
                &Producer::Camera::Lens::getAspectRatio)
            ;
    }

    {
        class_<Producer::Camera::Callback, Callback,
            bases<Producer::Referenced>, boost::noncopyable>
            callback("Callback");
    }

    {
        class_<Producer::Camera::Lens, Producer::ref_ptr<Producer::Camera::Lens>,
            bases<Producer::Referenced>, boost::noncopyable >
            lens("Lens", no_init);
        scope lens_scope(lens);

        lens.def(init<>())
            ;
    }

}
}