// 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.
//

#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/copy_const_reference.hpp>
#include <boost/python/scope.hpp>
#include <boost/python/overloads.hpp>
#include <boost/python/iterator.hpp>
#include <boost/python/call_method.hpp>
#include <boost/python/ptr.hpp>
#include <boost/python/return_opaque_pointer.hpp>

#include <iostream>

#include <osgProducer/OsgCameraGroup>


#include "OsgCameraGroup.hpp"
#include "producer_ptr.hpp"
#include "held_ptr.hpp"


using namespace boost::python;

namespace boost { namespace python {

template<class T> inline T * get_pointer(Producer::ref_ptr<T> & p)
{
    return p.get();
}

}} // namespace boost:python

struct make_producer_ref_holder
{
  typedef PyObject* result_type;
  template <class T>
  static result_type execute(T* p)
  {
      typedef Producer::ref_ptr<T> smart_pointer;
      typedef boost::python::objects::pointer_holder<smart_pointer, T> holder_t;

      smart_pointer ptr(p);
      return boost::python::objects::make_ptr_instance<T, holder_t>::execute(ptr);
  }
};

template <class R>
struct manage_producer_object_requires_a_reference_return_type
# if defined(__GNUC__) && __GNUC__ >= 3 || defined(__EDG__)
{}
# endif
;

struct manage_producer_ref
{
    template <class T>
    struct apply
    {
        typedef typename boost::mpl::if_c<
            boost::is_reference<T>::value
            , boost::python::to_python_indirect<T, make_producer_ref_holder>
            , manage_producer_object_requires_a_reference_return_type<T>
        >::type type;
    };
};


namespace {
BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(setFusionDistance_overloads, osgProducer::OsgCameraGroup::setFusionDistance, 1, 2);

class RealizeCallback : public osgProducer::OsgCameraGroup::RealizeCallback {
    public :
        RealizeCallback(PyObject * self) : _self(self) {Py_INCREF(_self);}
        ~RealizeCallback() {Py_DECREF(_self);}

        virtual void operator()(osgProducer::OsgCameraGroup& cg, osgProducer::OsgSceneHandler& sh, const Producer::RenderSurface & rs)
        {
            try {
                call_method<void>(_self, "apply", ptr(&cg), ptr(&sh), ptr(&rs));
            } catch(...) {
                handle_exception();
                PyErr_Print();
                throw_error_already_set();
                return;
            }
        }
    private:
        PyObject * _self;
};

void SceneHandlerList_push_back(osgProducer::OsgCameraGroup::SceneHandlerList& self, osgProducer::OsgSceneHandler * sh)
{
    self.push_back(sh);
}

osgProducer::OsgSceneHandler * SceneHandlerList_getitem(osgProducer::OsgCameraGroup::SceneHandlerList& self, int idx)
{
    // std::cerr << "getitem : idx = " << idx << std::endl;
    if (idx < 0 || idx >= int(self.size())) {
        PyErr_SetString(PyExc_IndexError, "Out of range");
        throw_error_already_set();
        return NULL;
    }
    return self[idx].get();
}


osg::Node * getSceneData(osgProducer::OsgCameraGroup * self)
{
    return self->getSceneData();
}

} // namespace

namespace PyOSG {

class_OsgCameraGroup * OsgCameraGroupClass = NULL;

void init_OsgCameraGroup()
{
    OsgCameraGroupClass = new class_OsgCameraGroup("OsgCameraGroup");

    scope camera_group_scope(*OsgCameraGroupClass);

    (*OsgCameraGroupClass)
        .def(init<Producer::CameraConfig *>())
        .def(init<const std::string& >())
        .def(init<osg::ArgumentParser&>())

        .def("setApplicationUsage",
            &osgProducer::OsgCameraGroup::setApplicationUsage)
        //osg::ApplicationUsage* getApplicationUsage()

        .def("getSceneHandlerList",
            (osgProducer::OsgCameraGroup::SceneHandlerList& (osgProducer::OsgCameraGroup::*)())
            &osgProducer::OsgCameraGroup::getSceneHandlerList,
            return_internal_reference<>())

        .def("setSceneData",
            &osgProducer::OsgCameraGroup::setSceneData)

        .def("getSceneData",
            // XXX Why doesn't the following  work - try osgoccluder.py with -m flag
            (osg::Node *(osgProducer::OsgCameraGroup::*)())
            &osgProducer::OsgCameraGroup::getSceneData,
            // &getSceneData,
            return_internal_reference<>())

        .def("setSceneDecorator",
            &osgProducer::OsgCameraGroup::setSceneDecorator)
        .def("getSceneDecorator",
            (osg::Group *(osgProducer::OsgCameraGroup::*)())
            &osgProducer::OsgCameraGroup::getSceneDecorator,
            return_internal_reference<>())

        .def("getTopMostSceneData",
            (osg::Node *(osgProducer::OsgCameraGroup::*)())
            &osgProducer::OsgCameraGroup::getTopMostSceneData,
            return_internal_reference<>())

        .def("setDisplaySettings",
            &osgProducer::OsgCameraGroup::setDisplaySettings)
        .def("getDisplaySettings",
            (osg::DisplaySettings *(osgProducer::OsgCameraGroup::*)())
            &osgProducer::OsgCameraGroup::getDisplaySettings,
            return_internal_reference<>())

        .def("setCullSettings",
             &osgProducer::OsgCameraGroup::setCullSettings)

        .def("getCullSettings",
            (osg::CullSettings &(osgProducer::OsgCameraGroup::*)())
            &osgProducer::OsgCameraGroup::getCullSettings,
            return_internal_reference<>())

        .def("sync",
            &osgProducer::OsgCameraGroup::sync)

        .def("setFrameStamp",
            &osgProducer::OsgCameraGroup::setFrameStamp)
        .def("getFrameStamp",
            (osg::FrameStamp *(osgProducer::OsgCameraGroup::*)())
            &osgProducer::OsgCameraGroup::getFrameStamp,
            return_internal_reference<>())


        .def("frame",
            &osgProducer::OsgCameraGroup::frame,
            "Dispatch the cull and draw for each of the Camera's for this frame.\n")

        .def("setLODScale",
            &osgProducer::OsgCameraGroup::setLODScale)

        .def("setFusionDistance",
            &osgProducer::OsgCameraGroup::setFusionDistance,
            setFusionDistance_overloads())

        .def("setRealizeCallback",
            &osgProducer::OsgCameraGroup::setRealizeCallback)

        .def("setView",
            &osgProducer::OsgCameraGroup::setView)

        .def("getViewMatrix",
            &osgProducer::OsgCameraGroup::getViewMatrix)

        .def("setGlobalStateSet",
            &osgProducer::OsgCameraGroup::setGlobalStateSet)

        .def("getGlobalStateSet",
            (osg::StateSet *(osgProducer::OsgCameraGroup::*)())
            &osgProducer::OsgCameraGroup::getGlobalStateSet,
            return_internal_reference<>())

        .def("setClearColor",
            &osgProducer::OsgCameraGroup::setClearColor)

        .def("getClearColor",
            (const osg::Vec4& (osgProducer::OsgCameraGroup::*)()const) &osgProducer::OsgCameraGroup::getClearColor,
            return_value_policy<copy_const_reference>())

        .def("getSceneHandlerList",
            (osgProducer::OsgCameraGroup::SceneHandlerList& (osgProducer::OsgCameraGroup::*)())
            &osgProducer::OsgCameraGroup::getSceneHandlerList,
            return_internal_reference<>())

        //             .def("setFusionDistance",
        //                 &OsgCameraGroup::setFusionDistance,
        //                 setFusionDistance_overloads())

        .def("setRealizeCallback",
            &osgProducer::OsgCameraGroup::setRealizeCallback)
        /** Set the realize callback to use when once the render surfaces are realized.*/

        /** Get the realize callback.*/
        // RealizeCallback* getRealizeCallback() { return _realizeCallback.get(); }

        .def("advance",
            &osgProducer::OsgCameraGroup::advance)

#if ((OSG_VERSION_MAJOR==1) & (OSG_VERSION_MINOR < 1))
        .def("realize",
            (bool (osgProducer::OsgCameraGroup::*)(Producer::CameraGroup::ThreadingModel))
            &osgProducer::OsgCameraGroup::realize)
#endif

        .def("realize",
            (bool (osgProducer::OsgCameraGroup::*)(void))
            &osgProducer::OsgCameraGroup::realize)

        .def("getViewMatrix",
            &osgProducer::OsgCameraGroup::getViewMatrix)

        .def("sync",
            &osgProducer::OsgCameraGroup::sync)

        .def("frame",
            &osgProducer::OsgCameraGroup::frame,
            "Dispatch the cull and draw for each of the Camera's for this frame.\n")
        ;

    class_<osgProducer::OsgCameraGroup::RealizeCallback, RealizeCallback, bases<osg::Referenced>, boost::noncopyable > realize_callback("RealizeCallback", no_init);
    realize_callback.def(init<>());

    class_<osgProducer::OsgCameraGroup::SceneHandlerList, boost::noncopyable> scenehandler_list("SceneHandlerList", no_init);
    scenehandler_list
        .def("push_back",
            SceneHandlerList_push_back)
        .def("size",
            &osgProducer::OsgCameraGroup::SceneHandlerList::size)
        .def("__len__",
            &osgProducer::OsgCameraGroup::SceneHandlerList::size)
        .def("__getitem__",
            &SceneHandlerList_getitem,
            return_internal_reference<>())
        // TODO , fix iterator
        // .def("__iter__",
        //     iterator<osgProducer::OsgCameraGroup::SceneHandlerList, return_value_policy<manage_producer_ref> >())
        ;
}
}