//
// Copyright 2016 Pixar
//
// Licensed under the Apache License, Version 2.0 (the "Apache License")
// with the following modification; you may not use this file except in
// compliance with the Apache License and the following modification to it:
// Section 6. Trademarks. is deleted and replaced with:
//
// 6. Trademarks. This License does not grant permission to use the trade
//    names, trademarks, service marks, or product names of the Licensor
//    and its affiliates, except as required to comply with Section 4(c) of
//    the License and to reproduce the content of the NOTICE file.
//
// You may obtain a copy of the Apache License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the Apache License with the above modification is
// distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
// KIND, either express or implied. See the Apache License for the specific
// language governing permissions and limitations under the Apache License.
//

#include "pxr/pxr.h"
#include "pxr/base/gf/matrix4d.h"
#include "pxr/base/gf/rotation.h"
#include "pxr/base/gf/transform.h"
#include "pxr/base/gf/vec3d.h"

#include "pxr/base/tf/stringUtils.h"
#include "pxr/base/tf/pyUtils.h"
#include "pxr/base/tf/wrapTypeHelpers.h"

#include <boost/python/args.hpp>
#include <boost/python/class.hpp>
#include <boost/python/copy_const_reference.hpp>
#include <boost/python/init.hpp>
#include <boost/python/operators.hpp>
#include <boost/python/return_arg.hpp>

#include <string>

using std::string;
using std::vector;
using namespace boost::python;

PXR_NAMESPACE_USING_DIRECTIVE

namespace {

static GfVec3d _NoTranslation() { return GfVec3d(0,0,0); }
static GfVec3d _IdentityScale() { return GfVec3d(1,1,1); }
static GfRotation _NoRotation() { return GfRotation( GfVec3d::XAxis(), 0.0 ); }

static string _Repr(GfTransform const &self)
{
    string prefix = TF_PY_REPR_PREFIX + "Transform(";
    string indent(prefix.size(), ' ');

    // Use keyword args for clarity.
    // Only use args that do not match the defaults.
    vector<string> kwargs;
    if (self.GetTranslation() != _NoTranslation())
        kwargs.push_back( "translation = " +
                          TfPyRepr(self.GetTranslation()) );
    if (self.GetRotation() != _NoRotation())
        kwargs.push_back( "rotation = " +
                          TfPyRepr(self.GetRotation()) );
    if (self.GetScale() != _IdentityScale())
        kwargs.push_back( "scale = " +
                          TfPyRepr(self.GetScale()) );
    if (self.GetPivotPosition() != _NoTranslation())
        kwargs.push_back( "pivotPosition = " +
                          TfPyRepr(self.GetPivotPosition()) );
    if (self.GetPivotOrientation() != _NoRotation())
        kwargs.push_back( "pivotOrientation = " +
                          TfPyRepr(self.GetPivotOrientation()) );

    return prefix + TfStringJoin(kwargs, string(", \n" + indent).c_str()) + ")";
}

} // anonymous namespace 

void wrapTransform()
{    
    typedef GfTransform This;

    class_<This>( "Transform", init<>() )

        .def(init<const GfVec3d&, const GfRotation&, const GfVec3d&,
                  const GfVec3d&, const GfRotation&>
             ((args("translation") = _NoTranslation(),
               args("rotation") = _NoRotation(),
               args("scale") = _IdentityScale(),
               args("pivotPosition") = _NoTranslation(),
               args("pivotOrientation") = _NoRotation()),
              "Initializer used by 3x code."))

        // This is the constructor used by 2x code.  Leave the initial
        // arguments as non-default to force the user to provide enough
        // values to indicate her intentions.
        .def(init<const GfVec3d &, const GfRotation &, const GfRotation&,
                  const GfVec3d &, const GfVec3d &>
             ((args("scale"),
               args("pivotOrientation"),
               args("rotation"),
               args("pivotPosition"),
               args("translation")),
              "Initializer used by old 2x code. (Deprecated)"))

        .def(init<const GfMatrix4d &>())

        .def( TfTypePythonClass() )

        .def( "Set",
              (This & (This::*)( const GfVec3d &, const GfRotation &,
                                 const GfVec3d &, const GfVec3d &,
                                 const GfRotation & ))( &This::Set ),
              return_self<>(),
             (args("translation") = _NoTranslation(),
              args("rotation") = _NoRotation(),
              args("scale") = _IdentityScale(),
              args("pivotPosition") = _NoTranslation(),
              args("pivotOrientation") = _NoRotation()))

        .def( "Set",
              (This & (This::*)( const GfVec3d &, const GfRotation &,
                                 const GfRotation &, const GfVec3d &,
                                 const GfVec3d &))&This::Set,
              return_self<>(),
              (args("scale"),
               args("pivotOrientation"),
               args("rotation"),
               args("pivotPosition"),
               args("translation")),
              "Set method used by old 2x code. (Deprecated)")

        .def( "SetMatrix", &This::SetMatrix, return_self<>() )
        .def( "GetMatrix", &This::GetMatrix )

        .def( "SetIdentity", &This::SetIdentity, return_self<>() )

        .add_property( "translation", make_function
                       (&This::GetTranslation,
                        return_value_policy<return_by_value>()),
                       &This::SetTranslation )

        .add_property( "rotation", make_function
                       (&This::GetRotation,
                        return_value_policy<return_by_value>()),
                       &This::SetRotation )

        .add_property( "scale", make_function
                       (&This::GetScale,
                        return_value_policy<return_by_value>()),
                       &This::SetScale )

        .add_property( "pivotPosition", make_function
                       (&This::GetPivotPosition,
                        return_value_policy<return_by_value>()),
                       &This::SetPivotPosition )

        .add_property( "pivotOrientation", make_function
                       (&This::GetPivotOrientation,
                        return_value_policy<return_by_value>()),
                       &This::SetPivotOrientation )

        .def("GetTranslation", &This::GetTranslation,
             return_value_policy<return_by_value>())
        .def("SetTranslation", &This::SetTranslation )

        .def("GetRotation", &This::GetRotation,
             return_value_policy<return_by_value>())
        .def("SetRotation", &This::SetRotation)

        .def("GetScale", &This::GetScale,
             return_value_policy<return_by_value>())
        .def("SetScale", &This::SetScale )

        .def("GetPivotPosition", &This::GetPivotPosition,
             return_value_policy<return_by_value>())
        .def("SetPivotPosition", &This::SetPivotPosition )

        .def("GetPivotOrientation", &This::GetPivotOrientation,
             return_value_policy<return_by_value>())
        .def("SetPivotOrientation", &This::SetPivotOrientation )


        .def( str(self) )
        .def( self == self )
        .def( self != self )
        .def( self *= self )
        .def( self * self )
        
        .def("__repr__", _Repr)

        ;
    
}