// 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/module.hpp>
#include <boost/python/def.hpp>
#include <boost/python/class.hpp>
#include <boost/python/scope.hpp>
#include <boost/python/enum.hpp>
#include <boost/python/call_method.hpp>
#include <boost/python/object.hpp>
#include <boost/python/extract.hpp>
#include <boost/python/return_value_policy.hpp>
#include <boost/python/return_by_value.hpp>
#include <boost/python/copy_const_reference.hpp>
#include <boost/ref.hpp>



#include <osg/CameraNode>
#include <osg/State>

#include <string>
#include <iostream>


#include "StateAttribute.hpp"
#include "Transform.hpp"
#include "held_ptr.hpp"
#include "lock.hpp"

using namespace boost::python;


namespace {

osg::CameraNode * asCameraNode(osg::StateAttribute * self) { return dynamic_cast<osg::CameraNode*>(self); }


class DrawCallbackCN : public osg::CameraNode::DrawCallback
{
 public:
    DrawCallbackCN(PyObject * p) : DrawCallback(), _self(p) {}
    ~DrawCallbackCN() {}

    virtual void operator()(const osg::CameraNode&)
    {
        // std::cerr << "PyNodeCallback::operator(), thread id = " << PyThread_get_thread_ident() << std::endl;
        PYOSG_LOCK_INTERPRETER();
        try {
            call_method<void>(_self, "apply" /*ref_ptr(osg::CameraNode)*/);
        } catch(...) {
            handle_exception();
            PyErr_Print();
        }
        PYOSG_RELEASE_INTERPRETER();
    }

  private:
      PyObject * _self;
};

void setPostDrawCallback(osg::CameraNode * self, PyObject * cb)
{
    bool is_callback = extract<osg::CameraNode::DrawCallback *>(cb).check();

    Py_XINCREF(cb);
    if (is_callback) {
        extract<osg::CameraNode::DrawCallback *> callback(cb);
        self->setPostDrawCallback(callback);
    } else {
        DrawCallbackCN * callback = new DrawCallbackCN(cb);
        self->setPostDrawCallback(callback);
    }
}
} // namespace

//namespace 
// {
//    DEFINE_TRANSFORM_CAST(CameraNode)
// }
namespace PyOSG
{
   void init_CameraNode()
   {
//       REGISTER_TRANSFORM_CAST(CameraNode)
      register_castStateAttribute("asCameraNode", &asCameraNode);
      class_<osg::CameraNode, osg::ref_ptr<osg::CameraNode>, bases<osg::Transform, osg::CullSettings>, boost::noncopyable> cameranode("CameraNode", no_init);

	  scope cameranode_scope(cameranode);
	  
	  cameranode
          .def(init<>())
      
          .def("setClearColor", 
                     &osg::CameraNode::setClearColor)
          .def("getClearColor",
                     &osg::CameraNode::getClearColor,
                     return_value_policy<copy_const_reference>())

          .def("setClearMask",
                     &osg::CameraNode::setClearMask)
          .def("getClearMask",
                     &osg::CameraNode::getClearMask)
      
          .def("setColorMask",
                     (void (osg::CameraNode::*)(osg::ColorMask*)) &osg::CameraNode::setColorMask)
          .def("setColorMask",
                     (void (osg::CameraNode::*)(bool, bool, bool, bool)) &osg::CameraNode::setColorMask)
          .def("getColorMask",
                     (const osg::ColorMask* (osg::CameraNode::*)() const) &osg::CameraNode::getColorMask,
                     return_value_policy<manage_osg_object>())

          .def("setViewport",
                     (void (osg::CameraNode::*)(osg::Viewport*)) &osg::CameraNode::setViewport)
          .def("setViewport",
                     (void (osg::CameraNode::*)(int, int, int, int)) &osg::CameraNode::setViewport)
          .def("getViewport",
                     (const osg::Viewport* (osg::CameraNode::*)() const) &osg::CameraNode::getViewport,
                     return_value_policy<manage_osg_object>())

          .def("setTransformOrder",
                     &osg::CameraNode::setTransformOrder)
          .def("getTransformOrder",
                     &osg::CameraNode::getTransformOrder)

#ifdef OSG_USE_DOUBLE_MATRICES
          .def("setProjectionMatrix",
                     (void (osg::CameraNode::*)(const osg::Matrixd& matrix)) &osg::CameraNode::setProjectionMatrix)
#else
          .def("setProjectionMatrix",
                     (void (osg::CameraNode::*)(const osg::Matrixf& matrix)) &osg::CameraNode::setProjectionMatrix)
#endif /* OSG_USE_DOUBLE_MATRICES */

          .def("setProjectionMatrixAsOrtho",
                     &osg::CameraNode::setProjectionMatrixAsOrtho)

          .def("setProjectionMatrixAsOrtho2D",
                     &osg::CameraNode::setProjectionMatrixAsOrtho2D)

          .def("setProjectionMatrixAsFrustum",
                     &osg::CameraNode::setProjectionMatrixAsFrustum)

          .def("setProjectionMatrixAsPerspective",
                     &osg::CameraNode::setProjectionMatrixAsPerspective)

#ifdef OSG_USE_DOUBLE_MATRICES
          .def("getProjectionMatrix",
                     (osg::Matrixd& (osg::CameraNode::*)()) &osg::CameraNode::getProjectionMatrix,
                     return_internal_reference<>())
#else
          .def("getProjectionMatrix",
                     (osg::Matrixf& (osg::CameraNode::*)()) &osg::CameraNode::getProjectionMatrix,
                     return_internal_reference<>())
#endif /* OSG_USE_DOUBLE_MATRICES */

          .def("getProjectionMatrixAsOrtho",
                     &osg::CameraNode::getProjectionMatrixAsOrtho)


          .def("getProjectionMatrixAsFrustum",
                     &osg::CameraNode::getProjectionMatrixAsFrustum)


          .def("getProjectionMatrixAsPerspective",
                     &osg::CameraNode::getProjectionMatrixAsPerspective)

#ifdef OSG_USE_DOUBLE_MATRICES
          .def("setViewMatrix",
                     (void (osg::CameraNode::*)(const osg::Matrixd &)) &osg::CameraNode::setViewMatrix)
#else
          .def("setViewMatrix",
                     (void (osg::CameraNode::*)(const osg::Matrixf &)) &osg::CameraNode::setViewMatrix)
#endif /* OSG_USE_DOUBLE_MATRICES */

          .def("setViewMatrixAsLookAt",
                     &osg::CameraNode::setViewMatrixAsLookAt)


          .def("getViewMatrix",
                     (const osg::Matrixd & (osg::CameraNode::*)() const) &osg::CameraNode::getViewMatrix,
                     return_value_policy<copy_const_reference>())

          .def("getViewMatrixAsLookAt",
                     &osg::CameraNode::getViewMatrixAsLookAt)

          .def("getInverseViewMatrix",
                     &osg::CameraNode::getInverseViewMatrix)

          .def("setRenderOrder",
                     &osg::CameraNode::setRenderOrder)
          .def("getRenderOrder",
                     &osg::CameraNode::getRenderOrder)
          .def("isRenderToTextureCamera()",
		     &osg::CameraNode::isRenderToTextureCamera)
          .def("setRenderTargetImplementation",
                     (void (osg::CameraNode::*)(osg::CameraNode::RenderTargetImplementation)) &osg::CameraNode::setRenderTargetImplementation)

          .def("getRenderTargetImplmentation",
                     (void (osg::CameraNode::*)(osg::CameraNode::RenderTargetImplementation const)) &osg::CameraNode::getRenderTargetImplementation)

          .def("setDrawBuffer",
                     &osg::CameraNode::setDrawBuffer)
          .def("getDrawBuffer",
                     &osg::CameraNode::getDrawBuffer)

          .def("setReadBuffer",
                     &osg::CameraNode::setReadBuffer)

          .def("getReadBuffer",
                     &osg::CameraNode::getReadBuffer)

          .def("attach",
                     (void (osg::CameraNode::*)(osg::CameraNode::BufferComponent, GLenum)) &osg::CameraNode::attach)

          .def("attach",
                     (void (osg::CameraNode::*)(osg::CameraNode::BufferComponent,
                                                osg::Texture *,
                                                unsigned int,
                                                unsigned int,
                                                bool)) &osg::CameraNode::attach)

          .def("attach",
                     (void (osg::CameraNode::*)(osg::CameraNode::BufferComponent, osg::Image*)) &osg::CameraNode::attach)

          .def("detach",
                     (void (osg::CameraNode::*)(osg::CameraNode::BufferComponent))&osg::CameraNode::detach)
          .def("setPostDrawCallback", &osg::CameraNode::setPostDrawCallback)

          ;
 //         .def("getPostDrawCallback", &osg::CameraNode::getPostDrawCallback);
    class_<osg::CameraNode::DrawCallback, osg::ref_ptr<DrawCallbackCN>, bases<osg::Referenced>, boost::noncopyable>("DrawCallback", no_init)
        .def(init<>())

        ;

#   define OSG_ENUM_MODE(VALUE) \
    (renderorder.value(#VALUE, osg::CameraNode::VALUE), \
        cameranode.def(#VALUE, object(osg::CameraNode::VALUE)))
    enum_<osg::CameraNode::RenderOrder> renderorder("RenderOrder");

    OSG_ENUM_MODE(PRE_RENDER);
    OSG_ENUM_MODE(NESTED_RENDER);
    OSG_ENUM_MODE(POST_RENDER);

#   define OSG_ENUM_TARGET(VALUE) \
    (rendertargetimplementation.value(#VALUE,osg::CameraNode::VALUE), \
        cameranode.def(#VALUE, object(osg::CameraNode::VALUE)))
    enum_<osg::CameraNode::RenderTargetImplementation>rendertargetimplementation("RenderTargetImplementation");

    OSG_ENUM_TARGET(FRAME_BUFFER_OBJECT);
    OSG_ENUM_TARGET(PIXEL_BUFFER_RTT);
    OSG_ENUM_TARGET(PIXEL_BUFFER);
    OSG_ENUM_TARGET(FRAME_BUFFER);
    OSG_ENUM_TARGET(SEPERATE_WINDOW);

#   define OSG_ENUM_BUFFER(VALUE) \
    (buffercomponent.value(#VALUE,osg::CameraNode::VALUE), \
        cameranode.def(#VALUE, object(osg::CameraNode::VALUE)))
    enum_<osg::CameraNode::BufferComponent>buffercomponent("BufferComponent");

    OSG_ENUM_BUFFER(DEPTH_BUFFER);
    OSG_ENUM_BUFFER(STENCIL_BUFFER);
    OSG_ENUM_BUFFER(COLOR_BUFFER);
    OSG_ENUM_BUFFER(COLOR_BUFFER0);
    OSG_ENUM_BUFFER(COLOR_BUFFER1);
    OSG_ENUM_BUFFER(COLOR_BUFFER2);
    OSG_ENUM_BUFFER(COLOR_BUFFER3);
    OSG_ENUM_BUFFER(COLOR_BUFFER4);
    OSG_ENUM_BUFFER(COLOR_BUFFER5);
    OSG_ENUM_BUFFER(COLOR_BUFFER6);
    OSG_ENUM_BUFFER(COLOR_BUFFER7);

   }
}