// 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/def.hpp>
#include <boost/python/class.hpp>
#include <boost/python/scope.hpp>
#include <boost/python/enum.hpp>
#include <boost/python/list.hpp>
#include <boost/python/extract.hpp>
#include <boost/python/iterator.hpp>
#include <boost/python/return_value_policy.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/IntersectVisitor>

#include <string>
#include <iostream>

#include "NodeVisitor.hpp"

using namespace boost::python;

namespace {
osgUtil::IntersectVisitor * asIntersectVisitor(osg::NodeVisitor * nv)
{
    return dynamic_cast<osgUtil::IntersectVisitor*>(nv);
}

osg::Geode * geode(osgUtil::Hit * self)
{
    if (self->_geode.valid()) {
        return self->_geode.get();
    }
    return NULL;
}

osg::Drawable * drawable(osgUtil::Hit * self)
{
    if (self->_drawable.valid()) {
        return self->_drawable.get();
    }
    return NULL;
}

inline osgUtil::Hit::VecIndexList * vecIndexList(osgUtil::Hit * self)
{
    return &self->_vecIndexList;
}

int __getitem__(osgUtil::Hit::VecIndexList * self, int idx)
{
    return (*self)[idx];
}

void init_Hit()
{
    class_<osgUtil::Hit> hit("Hit");

    scope hit_scope(hit);

    hit.def("getLocalIntersectPoint", 
            &osgUtil::Hit::getLocalIntersectPoint, return_internal_reference<>());
    hit.def("getLocalIntersectNormal", 
            &osgUtil::Hit::getLocalIntersectNormal, return_internal_reference<>());

    hit.def("getWorldIntersectPoint", 
            &osgUtil::Hit::getWorldIntersectPoint);
    hit.def("getWorldIntersectNormal", 
            &osgUtil::Hit::getWorldIntersectNormal);
    hit.def_readonly("_ratio", 
            &osgUtil::Hit::_ratio);
    hit.def("geode", 
            &geode, return_internal_reference<>());
    hit.def("drawable", 
            &drawable, return_internal_reference<>());
    hit.def("vecIndexList", 
            &vecIndexList, return_internal_reference<>());

    class_<osgUtil::Hit::VecIndexList> vec_index_list("VecIndexList");
    vec_index_list.def("__iter__", iterator<osgUtil::Hit::VecIndexList>());
    vec_index_list.def("size", &osgUtil::Hit::VecIndexList::size);
    vec_index_list.def("__getitem__", __getitem__);
}
#if 0
        osg::ref_ptr<osg::LineSegment>  _originalLineSegment;
        osg::ref_ptr<osg::LineSegment>  _localLineSegment;
        osg::NodePath                   _nodePath;
        osg::ref_ptr<osg::RefMatrix>    _matrix;
        osg::ref_ptr<osg::RefMatrix>    _inverse;
        
        VecIndexList                    _vecIndexList;
        int                             _primitiveIndex;
        osg::Vec3                       _intersectPoint;
        osg::Vec3                       _intersectNormal;
#endif
osgUtil::Hit * hitlist_front(osgUtil::IntersectVisitor::HitList &hlist)
{
    return &hlist.front();
}
} // namespace

namespace PyOSGUtil {
void init_IntersectVisitor()
{
    init_Hit();

    def("asIntersectVisitor", &asIntersectVisitor, return_internal_reference<>());

    class_<osgUtil::IntersectVisitor, bases<osg::NodeVisitor>, boost::noncopyable > intersect_visitor("IntersectVisitor", no_init);
    {
        scope intersect_visitor_scope(intersect_visitor);

        class_<osgUtil::IntersectVisitor::HitList> hitlist("HitList");
        hitlist
            .def("__iter__", 
                iterator<osgUtil::IntersectVisitor::HitList
               // , return_internal_reference<>()
                >())

            .def("empty",
                &osgUtil::IntersectVisitor::HitList::empty)

            .def("size",
                &osgUtil::IntersectVisitor::HitList::size)

            .def("max_size",
                &osgUtil::IntersectVisitor::HitList::max_size)

            .def("capacity",
                &osgUtil::IntersectVisitor::HitList::capacity)

            .def("front", 
                //&osgUtil::IntersectVisitor::HitList::front,
                &hitlist_front,
                return_internal_reference<>())
            ;

        intersect_visitor
            .def(init<>())

            .def("reset", 
                &osgUtil::IntersectVisitor::reset)

            .def("addLineSegment", 
                &osgUtil::IntersectVisitor::addLineSegment)
                /** Add a line segment to use for intersection testing during scene traversal.*/

            .def("getHitList",
                &osgUtil::IntersectVisitor::getHitList,
                return_internal_reference<>())

            .def("getNumHits", 
                &osgUtil::IntersectVisitor::getNumHits)

            .def("hits", 
                &osgUtil::IntersectVisitor::hits)

            ;
    }
}
}