#ifndef __JEULERANGLE3D__
#define __JEULERANGLE3D__

#include <istream>
#include <ostream>

#include "JIO/JSerialisable.hh"
#include "JLang/JManip.hh"
#include "JMath/JMath.hh"
#include "JMath/JConstants.hh"

#include "JGeometry3D/JAngle3D.hh"
#include "JGeometry3D/JVersor3D.hh"


/**
 * \author mdejong
 */

namespace JGEOMETRY3D {}
namespace JPP { using namespace JGEOMETRY3D; }

namespace JGEOMETRY3D {

  using JMATH::PI;
  using JMATH::JMath;
  using JIO::JReader;
  using JIO::JWriter;


  /**
   * Data structure for Euler angles in three dimensions.
   *
   * This class implements the JMATH::JMath interface.
   */
  class JEulerAngle3D :
    public JMath<JEulerAngle3D>
  {
  public:
    /**
     * Default constructor.
     */
    JEulerAngle3D() :
      __alpha(0.0),
      __beta (0.0),
      __gamma(0.0)
    {}


    /**
     * Constructor.
     *
     * \param  alpha    alpha angle [rad]
     * \param  beta     beta  angle [rad]
     * \param  gamma    gamma angle [rad]
     */
    JEulerAngle3D(const double alpha,
		  const double beta,
		  const double gamma) :
      __alpha(alpha),
      __beta (beta),
      __gamma(gamma)
    {}


    /**
     * Constructor.
     *
     * \param  angle    angle
     */
    JEulerAngle3D(const JAngle3D& angle) :
      __alpha(PI/2),
      __beta (angle.getTheta()),
      __gamma(angle.getPhi() + PI/2)
    {}


    /**
     * Constructor.
     *
     * \param  versor   versor
     */
    JEulerAngle3D(const JVersor3D& versor) :
      __alpha(PI/2),
      __beta (versor.getTheta()),
      __gamma(versor.getPhi() + PI/2)
    {}


    /**
     * Get Euler angle.
     *
     * \return          this angle
     */
    const JEulerAngle3D& getEulerAngle() const
    {
      return static_cast<const JEulerAngle3D&>(*this);
    }


    /**
     * Set Euler angle.
     *
     * \param  angle    Euler angle
     */
    void setEulerAngle(const JEulerAngle3D& angle)
    {
      static_cast<JEulerAngle3D&>(*this) = angle;
    }


    /**
     * Negate angle.
     *
     * \return          this angle
     */
    JEulerAngle3D& negate()
    {
      __alpha = -__alpha;
      __beta  = -__beta;
      __gamma = -__gamma;

      return *this;
    }


    /**
     * Add angle.
     *
     * \param  angle    angle
     * \return          this angle
     */
    JEulerAngle3D& add(const JEulerAngle3D& angle)
    {
      __alpha += angle.getAlpha();
      __beta  += angle.getBeta();
      __gamma += angle.getGamma();

      return *this;
    }


    /**
     * Subtract angle.
     *
     * \param  angle    angle
     * \return          this angle
     */
    JEulerAngle3D& sub(const JEulerAngle3D& angle)
    {
      __alpha -= angle.getAlpha();
      __beta  -= angle.getBeta();
      __gamma -= angle.getGamma();

      return *this;
    }


    /**
     * Scale angle.
     *
     * \param  factor   multiplication factor
     * \return          this angle
     */
    JEulerAngle3D& mul(const double factor)
    {
      __alpha *= factor;
      __beta  *= factor;
      __gamma *= factor;

      return *this;
    }


    /**
     * Scale angle.
     *
     * \param  factor   division factor
     * \return          this angle
     */
    JEulerAngle3D& div(const double factor)
    {
      __alpha /= factor;
      __beta  /= factor;
      __gamma /= factor;

      return *this;
    }


    /**
     * Get alpha angle.
     *
     * \return          alpha angle
     */
    double getAlpha() const 
    { 
      return __alpha;
    }


    /**
     * Get beta angle.
     *
     * \return          beta angle
     */
    double getBeta() const
    { 
      return __beta;
    }


    /**
     * Get gamma angle.
     *
     * \return          gamma angle
     */
    double getGamma() const 
    { 
      return __gamma;
    }


    /**
     * Read Euler angles from input.
     *
     * \param  in            input stream
     * \param  angle         Euler angles
     * \return               input stream
     */
    friend inline std::istream& operator>>(std::istream& in, JEulerAngle3D& angle)
    {
      in >> angle.__alpha  >> angle.__beta  >> angle.__gamma;

      return in;
    }


    /**
     * Write Euler angles to output.
     *
     * \param  out           output stream
     * \param  angle         Euler angle
     * \return               output stream
     */
    friend inline std::ostream& operator<<(std::ostream& out, const JEulerAngle3D& angle)
    {
       const JFormat format(out, getFormat<JAngle3D>(JFormat_t(9, 5, std::ios::fixed | std::ios::showpos)));

       out << format << angle.getAlpha() << ' ' 
	   << format << angle.getBeta()  << ' ' 
	   << format << angle.getGamma();

      return out;
    }


    /**
     * Read Euler angles from input.
     *
     * \param  in         reader
     * \param  angle      Euler angles
     * \return            reader
     */
    friend inline JReader& operator>>(JReader& in, JEulerAngle3D& angle)
    {
      in >> angle.__alpha;
      in >> angle.__beta;
      in >> angle.__gamma;

      return in;
    }


    /**
     * Write Euler angles to output.
     *
     * \param  out        writer
     * \param  angle      Euler angles
     * \return            writer
     */
    friend inline JWriter& operator<<(JWriter& out, const JEulerAngle3D& angle)
    {
      out << angle.__alpha;
      out << angle.__beta;
      out << angle.__gamma;

      return out;
    }


  protected:
    double __alpha;
    double __beta;
    double __gamma;
  };
}

#endif