// 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.
//
// TODO Make it derivable from python!

#include <boost/python/module.hpp>
#include <boost/python/class.hpp>
#include <boost/python/list.hpp>
#include <boost/python/extract.hpp>
#include <boost/python/iterator.hpp>
#include <boost/python/scope.hpp>
#include <boost/python/enum.hpp>
#include <boost/python/return_value_policy.hpp>
#include <boost/python/copy_const_reference.hpp>
#include <boost/python/return_internal_reference.hpp>
#include <boost/python/manage_new_object.hpp>
#include <boost/python/detail/api_placeholder.hpp>
#include <boost/ref.hpp>
#include <boost/lexical_cast.hpp>

#include <osgUtil/SceneView>
#include <osgUtil/CullVisitor>

#include <string>
#include <iostream>

#include "held_ptr.hpp"

using namespace boost::python;

namespace {
void setDefaults(osgUtil::SceneView& self)
{
    self.setDefaults();
}

osg::Node * getSceneData(osgUtil::SceneView& self)
{
    return self.getSceneData();
}

}


namespace PyOSGUtil {
void init_SceneView2(class_<osgUtil::SceneView, osg::ref_ptr<osgUtil::SceneView>, bases<osg::Referenced>, boost::noncopyable > & sceneview);
void init_SceneView3(class_<osgUtil::SceneView, osg::ref_ptr<osgUtil::SceneView>, bases<osg::Referenced>, boost::noncopyable > & sceneview);
void init_SceneView()
{
    class_<osgUtil::SceneView, osg::ref_ptr<osgUtil::SceneView>, bases<osg::Referenced>, boost::noncopyable > sceneview("SceneView", no_init);

    scope sceneview_scope(sceneview);

    sceneview
        .def(init<>())
        .def(init<osg::DisplaySettings *>())

        .def("setDefaults", &osgUtil::SceneView::setDefaults,
            args("options"),
            "setDefaults(Options)\n"
            "Set scene view to use default global state, light, camera\n"
            "and render visitor.\n")
        .def("setDefaults", &setDefaults)

        .def("setSceneData", &osgUtil::SceneView::setSceneData,
            "Set the data which to view. The data will typically be\n"
            "an osg::Scene but can be any osg::Node type.\n")

        .def("getSceneData", 
            (osg::Node *(osgUtil::SceneView::*)(unsigned int)) &osgUtil::SceneView::getSceneData,
            "Get the scene data which to view. The data will typically be\n"
            "an osg::Scene but can be any osg::Node type.\n",
            return_internal_reference<>())

        .def("getSceneData",
            &getSceneData,
            "Get the scene data which to view. The data will typically be\n"
            "an osg::Scene but can be any osg::Node type.\n",
            return_internal_reference<>())

        .def("setViewport", (void (osgUtil::SceneView::*)(osg::Viewport *)) &osgUtil::SceneView::setViewport,
            "Set the viewport of the scene view to use specfied osg::Viewport. \n")

        .def("setViewport", (void (osgUtil::SceneView::*)(int, int, int, int)) &osgUtil::SceneView::setViewport,
            "Set the viewport of the scene view to use specfied osg::Viewport. \n")

        .def("getViewport",
            (osg::Viewport * (osgUtil::SceneView::*)()) &osgUtil::SceneView::getViewport,
            return_internal_reference<>())


        .def("setDisplaySettings", &osgUtil::SceneView::setDisplaySettings,
            "Set the DisplaySettings. \n")

        .def("getDisplaySettings", (osg::DisplaySettings *(osgUtil::SceneView::*)())&osgUtil::SceneView::getDisplaySettings,
            "Get the DisplaySettings \n",
            return_internal_reference<>())

        .def("setClearColor", &osgUtil::SceneView::setClearColor,
            "Set the background color used in glClearColor().\n"
            "Defaults to an off blue color.\n")

        .def("getClearColor", &osgUtil::SceneView::getClearColor,
            "Get the background color.\n",
            return_value_policy<copy_const_reference>())

        .def("setGlobalStateSet", &osgUtil::SceneView::setGlobalStateSet)
        .def("getGlobalStateSet", (osg::StateSet *(osgUtil::SceneView::*)()) &osgUtil::SceneView::getGlobalStateSet,
                return_internal_reference<>())

        .def("setLightingMode", &osgUtil::SceneView::setLightingMode)
        .def("getLightingMode", &osgUtil::SceneView::getLightingMode)

        .def("setLight", &osgUtil::SceneView::setLight)
        .def("getLight", (osg::Light *(osgUtil::SceneView::*)()) &osgUtil::SceneView::getLight,
                return_internal_reference<>())

        .def("setState", &osgUtil::SceneView::setState)
        .def("getState", 
            (osg::State *(osgUtil::SceneView::*)()) 
            &osgUtil::SceneView::getState,
            return_internal_reference<>())

        .def("setProjectionMatrix", 
            (void (osgUtil::SceneView::*)(const osg::Matrix&)) 
            &osgUtil::SceneView::setProjectionMatrix,
            "set a projection matrix. Note, this will override a camera's projection matrix if it is not NULL.\n")

        .def("setProjectionMatrixAsOrtho", &osgUtil::SceneView::setProjectionMatrixAsOrtho,
        "Set to a orthographic projection. Args=(left, right, bottom, top, zNear, zFar) note: args doubles.\n" )

        .def("setProjectionMatrixAsOrtho2D", &osgUtil::SceneView::setProjectionMatrixAsOrtho2D,
        "Set to a orthographic projection. Args=(left, right, bottom, top) note: args are doubles.\n" )

        .def("setProjectionMatrixAsFrustum", &osgUtil::SceneView::setProjectionMatrixAsFrustum,
        "Args=(left, right, bottom, top, zNear, zFar) note: args are doubles.\n" )

        .def("setProjectionMatrixAsPerspective", &osgUtil::SceneView::setProjectionMatrixAsPerspective,
        "Create a symmetrical perspective projection, Args=(fovy, aspectRatio, zNear, zFar) note: doubles.\n" )

        .def("getProjectionMatrix", 
        (osg::Matrix &(osgUtil::SceneView::*)()) &osgUtil::SceneView::getProjectionMatrix, return_internal_reference<>())

        .def("getProjectionMatrixAsOrtho", &osgUtil::SceneView::getProjectionMatrixAsOrtho,
        "Note: this function will change the Args in place, Args=(left, right, bottom, top, zNear, zFar)\n")

        .def("getProjectionMatrixAsFrustum", &osgUtil::SceneView::getProjectionMatrixAsFrustum,
        "Note: this function will change the Args in place, Args=(left, right, bottom, top, zNear, zFar)")

        .def("getProjectionMatrixAsPerspective", &osgUtil::SceneView::getProjectionMatrixAsPerspective,
        "Note: this function will change the Args in place, Args=(fovy, aspectRatio, zNear, zFar")


        // TODO ask Robert if these are going to change - brett
        //.def("setViewMatrix",
        //(void (osgUtil::SceneView::*)(const osg::Matrixf&) &osgUtil::SceneView::setViewMatrix,
        //"osg::Matrixf (float) Set the view matrix. Setting the position of the world relative to the camera in camera coordinates.\n")

        //.def("setViewMatrix", 
        //(void (osgUtil::SceneView::*)(const osg::Matrixd&) &osgUtil::SceneView::setViewMatrix,
        //"osg::Matrixd (double) Set the view matrix. Setting the position of the world relative to the camera in camera coordinates.\n")

        .def("setViewMatrixAsLookAt", &osgUtil::SceneView::setViewMatrixAsLookAt,
        "Set to the position and orientation of view matrix, using the same convention as gluLookAt.\n")

        .def("getViewMatrix", 
        (osg::Matrixd&(osgUtil::SceneView::*)())&osgUtil::SceneView::getViewMatrix,
        return_internal_reference<>())

        .def("getViewMatrixAsLookAt", &osgUtil::SceneView::getViewMatrixAsLookAt,
        "Note: this function will change the args in place, Args=(vec3 eye, vec3 center, vec3 up, float lookDistance)\n")

        .def("setInitVisitor", &osgUtil::SceneView::setInitVisitor)

        .def("getInitVisitor", 
        (osg::NodeVisitor*(osgUtil::SceneView::*)()) &osgUtil::SceneView::getInitVisitor,
        return_internal_reference<>())

        .def("setUpdateVisitor", &osgUtil::SceneView::setUpdateVisitor)

        .def("getUpdateVisitor", 
        (osg::NodeVisitor*(osgUtil::SceneView::*)()) &osgUtil::SceneView::getUpdateVisitor,
        return_internal_reference<>())

        .def("setCullVisitor", &osgUtil::SceneView::setCullVisitor)

        .def("getCullVisitor", 
        (osgUtil::CullVisitor*(osgUtil::SceneView::*)())&osgUtil::SceneView::getCullVisitor,
        return_internal_reference<>())

        .def("setCullVisitorLeft", &osgUtil::SceneView::setCullVisitorLeft)

        .def("getCullVisitorLeft", 
        (osgUtil::CullVisitor*(osgUtil::SceneView::*)())&osgUtil::SceneView::getCullVisitorLeft,
        return_internal_reference<>())

        .def("setCullVisitorRight", &osgUtil::SceneView::setCullVisitorRight)

        .def("getCullVisitorRight", 
        (osgUtil::CullVisitor*(osgUtil::SceneView::*)())&osgUtil::SceneView::getCullVisitorRight,
        return_internal_reference<>())

        .def("setCollectOccludersVisitor", &osgUtil::SceneView::setCollectOccludersVisitor)

        .def("getProjectionMatrix", 
            (osg::Matrix& (osgUtil::SceneView::*)()) 
            &osgUtil::SceneView::getProjectionMatrix,
        return_internal_reference<>())

        .def("setStateGraph", &osgUtil::SceneView::setStateGraph)

        .def("getStateGraph", 
        (osgUtil::StateGraph*(osgUtil::SceneView::*)())&osgUtil::SceneView::getStateGraph,
        return_internal_reference<>())

        .def("setStateGraphLeft", &osgUtil::SceneView::setStateGraphLeft)

        .def("getStateGraphLeft", 
        (osgUtil::StateGraph*(osgUtil::SceneView::*)())&osgUtil::SceneView::getStateGraphLeft,
        return_internal_reference<>())

        .def("setStateGraphRight", &osgUtil::SceneView::setStateGraphRight)

        .def("getStateGraphRight", 
        (osgUtil::StateGraph*(osgUtil::SceneView::*)())&osgUtil::SceneView::getStateGraphRight,
        return_internal_reference<>())

        .def("setRenderStage", &osgUtil::SceneView::setRenderStage)

        .def("getRenderStage", 
        (osgUtil::RenderStage*(osgUtil::SceneView::*)())&osgUtil::SceneView::getRenderStage,
        return_internal_reference<>())

        .def("setRenderStageLeft", &osgUtil::SceneView::setRenderStageLeft)

        .def("getRenderStageLeft", 
        (osgUtil::RenderStage*(osgUtil::SceneView::*)())&osgUtil::SceneView::getRenderStageLeft,
        return_internal_reference<>())

        .def("setRenderStageRight", &osgUtil::SceneView::setRenderStageRight)

        .def("getRenderStageRight", 
        (osgUtil::RenderStage*(osgUtil::SceneView::*)())&osgUtil::SceneView::getRenderStageRight,
        return_internal_reference<>())

        .def("setDrawBufferValue", &osgUtil::SceneView::setDrawBufferValue,
        "Set the draw buffer value used at the start of each frame draw.\n")

        .def("getDrawBufferValue", &osgUtil::SceneView::getDrawBufferValue)

        .def("setFusionDistance", &osgUtil::SceneView::setFusionDistance,
        "Set the FusionDistanceMode and Value. Note, is used only when working in stereo.\n")

        .def("getFusionDistanceMode", &osgUtil::SceneView::getFusionDistanceMode)

        .def("getFusionDistanceValue", &osgUtil::SceneView::getFusionDistanceValue)

        .def("setPrioritizeTextures", &osgUtil::SceneView::setPrioritizeTextures,
        "set whether the draw method should call renderer->prioritizeTexture.\n")

        .def("getPrioritizeTextures", &osgUtil::SceneView::getPrioritizeTextures,
        "get whether the draw method should call renderer->prioritizeTexture.\n")

        .def("setComputeStereoMatricesCallback", &osgUtil::SceneView::setComputeStereoMatricesCallback)

        .def("getComputeStereoMatricesCallback", 
        (osgUtil::SceneView::ComputeStereoMatricesCallback*(osgUtil::SceneView::*)())
        &osgUtil::SceneView::getComputeStereoMatricesCallback,
        return_internal_reference<>())

        .def("projectWindowIntoObject", &osgUtil::SceneView::projectWindowIntoObject,
        "Note: function changes args in place, Args=(vec3 window, vec3 object)\n")

        .def("projectWindowXYIntoObject", &osgUtil::SceneView::projectWindowXYIntoObject,
        "Note: function changes args in place, Args=(int x, int y, vec3 near_point, vec3 far_point)\n")

        .def("projectObjectIntoWindow", &osgUtil::SceneView::projectObjectIntoWindow,
        "Note: function changes args in place, Args=(vec3 object, vec3 window)\n")

        .def("setFrameStamp", &osgUtil::SceneView::setFrameStamp)

        .def("getFrameStamp", &osgUtil::SceneView::getFrameStamp,
            return_internal_reference<>())

        .def("setViewMatrix", 
            (void (osgUtil::SceneView::*)(const osg::Matrix&)) 
            &osgUtil::SceneView::setViewMatrix,
            "Set the view matrix. Can be thought of as setting the position of the world relative to the camera in camera coordinates.\n")
        .def("init", &osgUtil::SceneView::init,
        "Do init traversal of attached scene graph using Init NodeVisitor.\n")

        .def("update", &osgUtil::SceneView::update,
        "Do app traversal of attached scene graph using App NodeVisitor.\n")

        .def("cull", &osgUtil::SceneView::cull,
        "Do cull traversal of attached scene graph using Cull NodeVisitor.\n")

        .def("draw", &osgUtil::SceneView::draw,
        "Do draw traversal of draw bins generated by cull traversal.\n")

        .def("flushDeletedGLObjects", &osgUtil::SceneView::flushDeletedGLObjects,
        "Flush all the OpenGL objects, such as texture objects, display lists etc.\n")

        .def("getViewMatrix", 
            (osg::Matrix& (osgUtil::SceneView::*)()) 
            &osgUtil::SceneView::getViewMatrix,
            return_internal_reference<>());

    // Had to split up the definition of sceneview, since it generated a ICE on Studio.Net
    init_SceneView2(sceneview);
    init_SceneView3(sceneview);

#   define OSG_ENUM_LMODE(VALUE) \
    (lmode.value(#VALUE, osgUtil::SceneView::VALUE), \
    sceneview.def(#VALUE, object(osgUtil::SceneView::VALUE)))
    enum_<osgUtil::SceneView::LightingMode> lmode("LightingMode");
    OSG_ENUM_LMODE( NO_SCENEVIEW_LIGHT);
    OSG_ENUM_LMODE( HEADLIGHT);
    OSG_ENUM_LMODE( SKY_LIGHT);
    OSG_ENUM_LMODE( COMPILE_GLOBJECTS_AT_INIT);
    OSG_ENUM_LMODE( STANDARD_SETTINGS);

#   define OSG_ENUM_FDMODE(VALUE) \
    (fdmode.value(#VALUE, osgUtil::SceneView::VALUE), \
    sceneview.def(#VALUE, object(osgUtil::SceneView::VALUE)))
    enum_<osgUtil::SceneView::FusionDistanceMode> fdmode("FusionDistanceMode");
    OSG_ENUM_FDMODE( USE_FUSION_DISTANCE_VALUE); /** Use fusion distance from the value set on the SceneView.*/
    OSG_ENUM_FDMODE( PROPORTIONAL_TO_SCREEN_DISTANCE); /** Compute the fusion distance by multiplying the screen distance by the  fusion distance value.*/

}
}