// Copyright (C) 2002-2005 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.

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

#include <boost/python/class.hpp>
#include <boost/python/return_internal_reference.hpp>
#include <boost/python/scope.hpp>
#include <boost/python/enum.hpp>
#include <boost/python/call_method.hpp>
#include <boost/python/overloads.hpp>
#include <boost/python/extract.hpp>
#include <boost/python/iterator.hpp>

#include <osgGA/GUIEventHandler>
#include <osgGA/GUIActionAdapter>
#include <osgGA/MatrixManipulator>

#include <osgProducer/OsgCameraGroup>
#include <osg/ArgumentParser>
#include <osgProducer/Viewer>

#include <iostream>
#include "OsgCameraGroup.hpp"

using namespace boost::python;

namespace {
class Viewer : public osgProducer::Viewer {
  public:
    Viewer() {}

    Viewer(osg::ArgumentParser& parser) : osgProducer::Viewer(parser) {}
    Viewer(const std::string & str) : osgProducer::Viewer(str) {}
    Viewer(Producer::CameraConfig * cfg) : osgProducer::Viewer(cfg) {}

    void setUpViewer_0() { osgProducer::Viewer::setUpViewer(); }
    void setUpViewer_1(unsigned int options) { osgProducer::Viewer::setUpViewer(options); }
    void setUpViewer_2(osgProducer::Viewer::ViewerOptions options) { osgProducer::Viewer::setUpViewer(options); }

  /*
    unsigned int addCameraManipulator(PyObject * cm)
    {
        Py_XINCREF(cm);
        bool is_cameramanipulator = extract<osgGA::MatrixManipulator *>(cm).check();
        if (is_cameramanipulator) {
            extract<osgGA::MatrixManipulator *> manipulator(cm);
            return osgProducer::Viewer::addCameraManipulator(manipulator);
        } else {
            std::cerr << "addCameraManipulator : object NOT subclassed from osgGA.MatrixManipulator\n";
            // CameraManipulator * manipulator = new CameraManipulator(cm);
            // return osgProducer::Viewer::addCameraManipulator(manipulator);
            return false;
        }
    }
  */
        /** compute, from normalized mouse coords, for all Cameras, intersections with the specified subgraph.*/
        bool computeIntersections_1(float x,float y,unsigned int cameraNum,osg::Node *node,osgUtil::IntersectVisitor::HitList& hits,osg::Node::NodeMask traversalMask)
        {
            return osgProducer::Viewer::computeIntersections(x, y, cameraNum, node, hits, traversalMask);
        }
        bool computeIntersections_2(float x,float y,unsigned int cameraNum,osg::Node *node,osgUtil::IntersectVisitor::HitList& hits)
        {
            return osgProducer::Viewer::computeIntersections(x, y, cameraNum, node, hits);
        }

        /** compute, from normalized mouse coords, for sepecified Camera, intersections with the scene.*/
        bool computeIntersections_3(float x,float y,unsigned int cameraNum,osgUtil::IntersectVisitor::HitList& hits,osg::Node::NodeMask traversalMask)
        {
            return osgProducer::Viewer::computeIntersections(x, y, cameraNum, hits, traversalMask);
        }
        bool computeIntersections_4(float x,float y,unsigned int cameraNum,osgUtil::IntersectVisitor::HitList& hits,osg::Node::NodeMask traversalMask)
        {
            return osgProducer::Viewer::computeIntersections(x, y, cameraNum, hits);
        }

        /** compute, from normalized mouse coords, for all Cameras, intersections with specified subgraph.*/
        bool computeIntersections_5(float x,float y,osg::Node *node,osgUtil::IntersectVisitor::HitList& hits,osg::Node::NodeMask traversalMask)
        {
            return osgProducer::Viewer::computeIntersections(x, y, node, hits, traversalMask);
        }
        bool computeIntersections_6(float x,float y,osg::Node *node,osgUtil::IntersectVisitor::HitList& hits)
        {
            return osgProducer::Viewer::computeIntersections(x, y, node, hits);
        }

        /** compute, from normalized mouse coords, for all Cameras, intersections with the scene.*/
        bool computeIntersections_7(float x,float y,osgUtil::IntersectVisitor::HitList& hits,osg::Node::NodeMask traversalMask)
        {
            return osgProducer::Viewer::computeIntersections(x, y, hits, traversalMask);
        }
        bool computeIntersections_8(float x,float y,osgUtil::IntersectVisitor::HitList& hits)
        {
            return osgProducer::Viewer::computeIntersections(x, y, hits);
        }
};


void addEventHandler_front(Viewer& viewer, osgGA::GUIEventHandler * eh)
{
    viewer.getEventHandlerList().push_front(eh);
}

// Wrappers for the EventHandlerList stl methods
void EventHandlerList_push_front(osgProducer::Viewer::EventHandlerList& self, osgGA::GUIEventHandler * eh)
{
    self.push_front(eh);
}

void EventHandlerList_push_back(osgProducer::Viewer::EventHandlerList& self, osgGA::GUIEventHandler * eh)
{
    self.push_back(eh);
}
}

namespace PyOSG {

void init_Viewer()
{
    class_<Viewer, bases<osgProducer::OsgCameraGroup, osgGA::GUIActionAdapter> > viewer("Viewer");

    scope viewer_scope(viewer);
    viewer
        .def(init<Producer::CameraConfig *>())
        .def(init<const std::string& >())
        .def(init<osg::ArgumentParser&>())
        .def("setUpViewer",
            &Viewer::setUpViewer_0)
        .def("setUpViewer",
            &Viewer::setUpViewer_1)
        .def("setUpViewer",
            &Viewer::setUpViewer_2)
        .def("done",
            &Viewer::done)
        .def("setViewByMatrix",
            &Viewer::setViewByMatrix)
        .def("realize", 
            (bool (Viewer::*)()) &Viewer::realize)
#if ((OSG_VERSION_MAJOR==1) && (OSG_VERSION_MINOR < 2))
        .def("realize", 
            (bool (Viewer::*)(Producer::CameraGroup::ThreadingModel)) &Viewer::realize)
#endif
        .def("update", 
            &Viewer::update)
        .def("frame",  
            &Viewer::frame)
        .def("getUsage", 
            &Viewer::getUsage)
      /*
        .def("addCameraManipulator", 
            &Viewer::addCameraManipulator)
      */
        .def("selectCameraManipulator", 
            &Viewer::selectCameraManipulator)

        .def("computeIntersections", &Viewer::computeIntersections_1)
        .def("computeIntersections", &Viewer::computeIntersections_2)
        .def("computeIntersections", &Viewer::computeIntersections_3)
        .def("computeIntersections", &Viewer::computeIntersections_4)
        .def("computeIntersections", &Viewer::computeIntersections_5)
        .def("computeIntersections", &Viewer::computeIntersections_6)
        .def("computeIntersections", &Viewer::computeIntersections_7)
        .def("computeIntersections", &Viewer::computeIntersections_8)
        .def("getKeyboardMouse", 
                (Producer::KeyboardMouse* (osgProducer::Viewer::*)()) &Viewer::getKeyboardMouse,
                return_internal_reference<>())

        // bool computeIntersections(float x,float y,osgUtil::IntersectVisitor::HitList& hits);

#if 0
        .def("eventHandler_push_front", 
            &addEventHandler_front)
#else
        .def("getEventHandlerList",
            (osgProducer::Viewer::EventHandlerList& (osgProducer::Viewer::*)())
            &osgProducer::Viewer::getEventHandlerList,
            return_internal_reference<>())
#endif
        ;

        class_<osgProducer::Viewer::EventHandlerList, boost::noncopyable> eventhandler_list("EventHandlerList", no_init);
        eventhandler_list
//            .def("insert", 
//                &osgProducer::OsgCameraGroup::SceneHandlerList::insert)
            .def("push_front", 
                EventHandlerList_push_front)
                // &osgProducer::Viewer::EventHandlerList::push_front)
            .def("push_back", 
                EventHandlerList_push_back)
                // &osgProducer::Viewer::EventHandlerList::push_back)
            .def("size", 
                &osgProducer::Viewer::EventHandlerList::size)
            .def("__len__", 
                &osgProducer::Viewer::EventHandlerList::size)
            .def("__iter__",
                iterator<osgProducer::Viewer::EventHandlerList, return_internal_reference<> >())
            ;
#   define ENUM_OPTIONS(VALUE) \
    (options.value(#VALUE, osgProducer::Viewer::VALUE), \
    viewer.def(#VALUE, object(osgProducer::Viewer::VALUE)))
    enum_<osgProducer::Viewer::ViewerOptions> options("ViewerOptions");
    ENUM_OPTIONS(NO_EVENT_HANDLERS);
    ENUM_OPTIONS(TRACKBALL_MANIPULATOR);
    ENUM_OPTIONS(DRIVE_MANIPULATOR);
    ENUM_OPTIONS(FLIGHT_MANIPULATOR);
    ENUM_OPTIONS(STATE_MANIPULATOR);
    ENUM_OPTIONS(HEAD_LIGHT_SOURCE);
    ENUM_OPTIONS(SKY_LIGHT_SOURCE);
    ENUM_OPTIONS(STATS_MANIPULATOR);
    ENUM_OPTIONS(VIEWER_MANIPULATOR);
    ENUM_OPTIONS(ESCAPE_SETS_DONE);
    ENUM_OPTIONS(STANDARD_SETTINGS);
}
}