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

#include <boost/python/class.hpp>
#include <boost/python/scope.hpp>
#include <boost/python/tuple.hpp>
#include <boost/python/enum.hpp>
#include <boost/python/return_internal_reference.hpp>
#include <boost/python/return_value_policy.hpp>
#include <boost/python/copy_const_reference.hpp>

#include <osg/CoordinateSystemNode>

#include <string>
#include <iostream>
#include <boost/ref.hpp>

#include "Node.hpp"
#include "held_ptr.hpp"

using namespace boost::python;

namespace {
DEFINE_NODE_CAST(CoordinateSystemNode)
}

namespace PyOSG {
void init_CoordinateSystemNode()
{
    REGISTER_NODE_CAST(CoordinateSystemNode)

    class_<osg::EllipsoidModel, osg::ref_ptr<osg::EllipsoidModel>, bases<osg::Object> > ellipsoid("EllipsoidMode",
        "EllipsoidModel encapsulates the ellipsoid used to model astronomical bodies,\n"
        "such as sun, planets, moon etc.\n",
        no_init);

    ellipsoid.def(init<>())
        .def("setRadiusEquator",
            &osg::EllipsoidModel::setRadiusEquator)
        .def("getRadiusEquator",
            &osg::EllipsoidModel::getRadiusEquator)

        .def("setRadiusPolar",
            &osg::EllipsoidModel::setRadiusPolar)
        .def("getRadiusPolar",
            &osg::EllipsoidModel::getRadiusPolar)
        ;

#if 0 // Not implemented yet
        inline void convertLatLongHeightToXYZ(double latitude, double longitude, double height,
                                              double& X, double& Y, double& Z) const;

        inline void convertXYZToLatLongHeight(double X, double Y, double Z,
                                              double& latitude, double& longitude, double& height) const;

        inline void computeLocalToWorldTransformFromLatLongHeight(double latitude, double longitude, double height, osg::Matrixd& localToWorld) const;

        inline void computeLocalToWorldTransformFromXYZ(double X, double Y, double Z, osg::Matrixd& localToWorld) const;

        inline osg::Vec3d computeLocalUpVector(double X, double Y, double Z) const;
#endif

    class_<osg::CoordinateSystemNode, osg::ref_ptr<osg::CoordinateSystemNode>, bases<osg::Group> > csysnode("CoordinateSystemNode", 
        "CoordinateSystem encapsulate the coordinate system that is associated with objects in a scene.\n"
        "For an overview of common earth bases coordinate systems see http://www.colorado.edu/geography/gcraft/notes/coordsys/coordsys_f.html \n",
        no_init);

    scope csys_scope(csysnode);
    csysnode.def(init<>())
         .def("setFormat",
            &osg::CoordinateSystemNode::setFormat)

         .def("getFormat",
            &osg::CoordinateSystemNode::getFormat,
            return_value_policy<copy_const_reference>())

         .def("setCoordinateSystem",
            &osg::CoordinateSystemNode::setCoordinateSystem)

         .def("getCoordinateSystem",
            &osg::CoordinateSystemNode::getCoordinateSystem,
            return_value_policy<copy_const_reference>())

         .def("setEllipsoidModel",
            &osg::CoordinateSystemNode::setEllipsoidModel)

         .def("getEllipsoidModel",
            (osg::EllipsoidModel *(osg::CoordinateSystemNode::*)())
            &osg::CoordinateSystemNode::getEllipsoidModel,
            return_value_policy<manage_osg_object>())

#if 0 // Not implemented yet
        /** Compute the local coordinate frame for specified point.*/
        CoordinateFrame computeLocalCoordinateFrame(const Vec3d& position) const;

        /** Compute the local coordinate frame for specified point.*/
        osg::Vec3d computeLocalUpVector(const Vec3d& position) const;
#endif
         ;
}
}