/* -*-c++-*- osgPython - Copyright (C) 2006 Miguel Escriva Gregori 
 *
 * This library is open source and may be redistributed and/or modified under  
 * the terms of the OpenSceneGraph Public License (OSGPL) version 0.0 or 
 * (at your option) any later version.  The full license is in LICENSE file
 * included with this distribution, and on the openscenegraph.org website.
 * 
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the 
 * OpenSceneGraph Public License for more details.
*/

#include <Python.h>
#include <boost/python.hpp>
#include <iostream>
#include <osgIntrospection/Value>
#include <osgIntrospection/Type>
#include <osgIntrospection/ReaderWriter>
#include <osg/NodeCallback>
#include <osg/Vec2>
#include <osg/Vec3>
#include <osg/Vec4>
#include <osg/Quat>
#include <osg/Quat>


using namespace boost::python;

namespace osgPython {

		template <class T>
		std::string my_str(T& self)
		{
			osgIntrospection::Value value = osgIntrospection::Value(self);
			const osgIntrospection::Type& type = value.getType();
			const osgIntrospection::ReaderWriter *rw = type.getReaderWriter();
			if (rw != NULL){
				std::stringstream ss;
				rw->writeTextValue(ss, value);
				return ss.str();
			}
			return "";
		}

		template <class T>
		std::string my_repr(T& self)
		{
			osgIntrospection::Value value = osgIntrospection::Value(self);
			const osgIntrospection::Type& type = value.getInstanceType();
			return type.getQualifiedName() + "(" + my_str<T>(self) + ")";
		}

		template <class T> void set(T* self, T& from) { *self = from; }
		template <class T> void __setitem__(T* self, int idx, float val) { (*self)[idx] = val; }
		template <class T, class R> R __getitem__(T* self, int idx) { return (*self)[idx]; }


		template <class T> float get_0(T* self) { return self->_v[0]; }
		template <class T> float get_1(T* self) { return self->_v[1]; }
		template <class T> float get_2(T* self) { return self->_v[2]; }
		template <class T> float get_3(T* self) { return self->_v[3]; }
		
		template <class T> void  set_0(T* self, float x) { self->_v[0] = x; }
		template <class T> void  set_1(T* self, float x) { self->_v[1] = x; }
		template <class T> void  set_2(T* self, float x) { self->_v[2] = x; }
		template <class T> void  set_3(T* self, float x) { self->_v[3] = x; }



void initBasicTypes()
{
	class_<osg::Vec2>("Vec2", "General purpose float pair.")
		.def(init<float, float>())
	
    	.def(self == self)
		.def(self != self)
		.def(self < self)
	
    	.def("set", &osg::Vec2::set)
		.def("set", &set<osg::Vec2>)
		.def("__getitem__", &__getitem__<osg::Vec2, float>)
		.def("__setitem__", &__setitem__<osg::Vec2>)
		.add_property("x", &get_0<osg::Vec2>, &set_0<osg::Vec2>)
    	.add_property("y", &get_1<osg::Vec2>, &set_1<osg::Vec2>)
		.def("valid", &osg::Vec2::valid)
		.def("isNaN", &osg::Vec2::isNaN)
		.def(self * self)
		.def(self * float())
    	.def(self *= float())
		.def(self / float())
		.def(self /= float())
		.def(self + self)
		.def(self += self)
    	.def(self - self)
		.def(self -= self)
		.def(-self)
		.def("length", &osg::Vec2::length, "Length of the vector = sqrt( vec . vec )")
		.def("length2", &osg::Vec2::length2, "Length squared of the vector = vec . vec")
		.def("normalize", &osg::Vec2::normalize, 	"Normalize the vector so that it has length unity.\nReturns the previous length of the vector." )
		.def("__str__", &my_str<osg::Vec2>)
		.def("__repr__", &my_repr<osg::Vec2>)
	;

	class_<osg::Vec3>("Vec3", "General purpose float triple for use as vertices, vectors and normals.", no_init)
		//.def(init<float, float, float>())
		//.def(init<osg::Vec2, float>())
	
		.def(self == self)
		.def(self != self)
		.def(self < self)
	
		// next lines crash windows compiler.
		//.def("set", (void (osg::Vec3::*)(float, float, float)) &osg::Vec3::set)
		//.def("set", (void (osg::Vec3::*)(const osg::Vec3&)) &osg::Vec3::set)
    	.def("__getitem__", &__getitem__<osg::Vec3, float>)
    	.def("__setitem__", &__setitem__<osg::Vec3>)

		.add_property("x", &get_0<osg::Vec3>, &set_0<osg::Vec3>)
    	.add_property("y", &get_1<osg::Vec3>, &set_1<osg::Vec3>)
		.add_property("z", &get_2<osg::Vec3>, &set_2<osg::Vec3>)
	
		.def("valid", &osg::Vec2::valid)
    	.def("isNaN", &osg::Vec2::isNaN)
		.def(self * self)
		.def(self ^ self)
		.def(self * float())
		.def(self *= float())
    	.def(self / float())
		.def(self /= float())
		.def(self + self)
		.def(self += self)
		.def(self - self)
    	.def(self -= self)
		.def(-self)
		.def("length", &osg::Vec3::length, "Length of the vector = sqrt( vec . vec )")
		.def("length2", &osg::Vec3::length2, "Length squared of the vector = vec . vec")
		.def("normalize", &osg::Vec3::normalize, 	"Normalize the vector so that it has length unity.\nReturns the previous length of the vector." )
    	.def("__str__", &my_str<osg::Vec3>)
		.def("__repr__", &my_repr<osg::Vec3>)
	;	
		
	class_<osg::Vec4>("Vec4", "General purpose float quad.", no_init)
		//.def(init<float, float, float, float>())
		//.def(init<osg::Vec3, float>())
    
		.def(self == self)
		.def(self != self)
		.def(self < self)
    
		.def("set", &osg::Vec4::set)
		.def("set", &set<osg::Vec4>)
		.def("__getitem__", &__getitem__<osg::Vec4, float>)
		.def("__setitem__", &__setitem__<osg::Vec4>)
    
		.add_property("x", &get_0<osg::Vec4>, &set_0<osg::Vec4>)
		.add_property("y", &get_1<osg::Vec4>, &set_1<osg::Vec4>)
		.add_property("z", &get_2<osg::Vec4>, &set_2<osg::Vec4>)
		.add_property("w", &get_3<osg::Vec4>, &set_3<osg::Vec4>)
    
		.add_property("r", &get_0<osg::Vec4>, &set_0<osg::Vec4>)
		.add_property("g", &get_1<osg::Vec4>, &set_1<osg::Vec4>)
		.add_property("b", &get_2<osg::Vec4>, &set_2<osg::Vec4>)
		.add_property("a", &get_3<osg::Vec4>, &set_3<osg::Vec4>)
    
		.def("asABGR", &osg::Vec4::asABGR)
		.def("asRGBA", &osg::Vec4::asRGBA)
		.def("valid", &osg::Vec4::valid)
		.def("isNaN", &osg::Vec4::isNaN)
		.def(self * self)
		.def(self * float())
		.def(self *= float())
		.def(self / float())
		.def(self /= float())
		.def(self + self)
		.def(self += self)
		.def(self - self)
		.def(self -= self)
		.def(-self)
		.def("length", &osg::Vec4::length, "Length of the vector = sqrt( vec . vec )")
		.def("length2", &osg::Vec4::length2, "Length squared of the vector = vec . vec")
		.def("normalize", &osg::Vec4::normalize, 	"Normalize the vector so that it has length unity.\nReturns the previous length of the vector." )
		.def("__str__", &my_str<osg::Vec4>)
		.def("__repr__", &my_str<osg::Vec4>)
	;

    class_<osg::Quat>("Quat", "A quaternion class.", no_init)
		//.def(init<float, float, float, float>())
		//.def(init<const osg::Vec4&>())
        //.def(init<float, const osg::Vec3&>())
		//.def(init<float, const osg::Vec3&, float, const osg::Vec3&, float, const osg::Vec3&>())
		
		.def(self == self)
        .def(self != self)
		.def(self < self)
		
		.def("asVec4", (osg::Vec4&(osg::Quat::*)()) &osg::Quat::asVec4, return_internal_reference<>())
		.def("asVec3", (osg::Vec3&(osg::Quat::*)()) &osg::Quat::asVec3, return_internal_reference<>())
        .def("set", (void (osg::Quat::*)(double, double, double, double))&osg::Quat::set)
		.def("set", (void (osg::Quat::*)(const osg::Vec4&))&osg::Quat::set)
		// TODO .def("get",...)
		
		.def("__getitem__", &__getitem__<osg::Quat, double>)
        .def("__setitem__", &__setitem__<osg::Quat>)
		
		.add_property("x", &get_0<osg::Quat>, &set_0<osg::Quat>)
		.add_property("y", &get_1<osg::Quat>, &set_1<osg::Quat>)
		.add_property("z", &get_2<osg::Quat>, &set_2<osg::Quat>)
        .add_property("w", &get_3<osg::Quat>, &set_3<osg::Quat>)
		.def("zeroRotation", &osg::Quat::zeroRotation, "return true if the Quat represents a zero rotation, and therefore can be ignored in computations.")
		.def(self * float())
		.def(self *= float())
		.def(self * self)
		.def(self *= self)
		.def(self / float())
		.def(self /= float())
		.def(self / self)
		.def(self /= self)
		.def(self + self)
		.def(self += self)
		.def(self - self)
		.def(self -= self)
		.def(-self)
		.def("length", &osg::Quat::length, "Length of the quaternion = sqrt( vec . vec )")
		.def("length2", &osg::Quat::length2, "Length of the quaternion =  vec . vec ")
		
		.def("conj", &osg::Quat::conj, "Conjugate")
		.def("inverse", &osg::Quat::inverse, "Multiplicative inverse method: q^(-1) = q^*/(q.q^*)")
		.def("makeRotate", (void (osg::Quat::*)(double, double, double, double))&osg::Quat::makeRotate)
		.def("makeRotate", (void (osg::Quat::*)(double, const osg::Vec3&))&osg::Quat::makeRotate)
        .def("makeRotate", (void (osg::Quat::*)(const osg::Vec3&, const osg::Vec3&))&osg::Quat::makeRotate,
		    "Make a rotation Quat which will rotate vec1 to vec2.\n"
		    "Generally take adot product to get the angle between these\n"
		    "and then use a cross product to get the rotation axis\n"
            "Watch out for the two special cases of when the vectors\n"
		    "are co-incident or opposite in direction.\n")
		// TODO .def("getRotate",...
		.def("slerp", &osg::Quat::slerp,
		    "Spherical Linear Interpolation.\n"
            "As t goes from 0 to 1, the Quat object goes from 'from' to 'to'. \n")
		
		.def(self * osg::Vec3())
		.def("__str__", &my_str<osg::Quat>)
		.def("__repr__", &my_repr<osg::Quat>)
	;

		
}
    
		
} //end of osgPython namespace