#ifndef __VECTOR3D_H__
#define __VECTOR3D_H__

#include <fstream>
#include <iostream>

#define ABS(x) ((x)>0?(x):(-x))
#define MAX(x,y) ((x)>(y)?(x):(y))
#define MIN(x,y) ((x)<(y)?(x):(y))
#define RAD2DEG(x) (180*(x)/M_PI)
#define DEG2RAD(x) (M_PI*(x)/180)
#define ALMOST_ZERO 0.0001


double normalize(double min, double max, double value);

namespace Geometry
{
	// Messy but needed predeclarations
	template <class T> class Vector3D;
	template <class T> Vector3D<T> operator* (T factor, const Vector3D<T>& v);
	template <class T> std::ostream& operator<< (std::ostream& out, const Vector3D<T>& v);
	template <class T> std::istream& operator>> (std::istream& in, Vector3D<T>& v);

	// Vector3D class
	template <class T>
  class Vector3D
  {
  public:
    Vector3D(const Vector3D<T>& v);
    explicit Vector3D();
    explicit Vector3D(const T& x, const T& y, const T& z);
    explicit Vector3D(const T data[3]);
    explicit Vector3D(const Vector3D<T>* v);

    Vector3D<T>& operator=(const Vector3D<T>& src);
    bool operator==(const Vector3D<T>& src) const;

    void getSpheric(double& theta, double& phi) const;
    void getSpheric(double& distance, double& theta, double& phi) const;
    void setSpheric(double distance, double theta, double phi);

    const T& x() const { return _data[0]; };
    const T& y() const { return _data[1]; };
    const T& z() const { return _data[2]; };
    void x(const T& t) { _data[0] = t; };
    void y(const T& t) { _data[1] = t; };
    void z(const T& t) { _data[2] = t; };

    T& operator[](int index);
    const T* getData() const {return _data;};
    T* getDataRef() {return _data;};

    friend std::ostream& operator<< <>(std::ostream& out, const Vector3D<T>& v);
    friend std::istream& operator>> <>(std::istream& in, Vector3D<T>& v);

    void normalize();
    double module() const;
    double squaredModule() const;
    double angle(const Vector3D<T>& v) const;
    double distance(const Vector3D<T>& v) const;
    double squaredDistance(const Vector3D<T>& v) const;
    double infDistance(const Vector3D<T>& v) const;
    double manhattanDistance(const Vector3D<T>& v) const;

    void rotateX(double angle);
    void rotateY(double angle);
    void rotateZ(double angle);

    double dotProduct(const Vector3D<T>& v) const;
    double operator*(const Vector3D<T>& v) const;

    Vector3D<T> operator/(T factor) const;
    const Vector3D<T>& operator/=(T factor);

    Vector3D<T> operator*(T factor) const;
    const Vector3D<T>& operator*=(T factor);
    friend Vector3D<T> operator* <>(T factor, const Vector3D<T>& v);

    Vector3D<T> crossProduct(const Vector3D<T>& v) const;
    Vector3D<T> operator^(const Vector3D<T>& v) const;

    Vector3D<T> difference(const Vector3D<T>& v) const;
    Vector3D<T> operator-(const Vector3D<T>& v) const;
    const Vector3D<T>& substract(const Vector3D<T>& v);
    const Vector3D<T>& operator-=(const Vector3D<T>& v);
    friend Vector3D<T> operator- <>(const Vector3D<T>& v);

    Vector3D<T> sum(const Vector3D<T>& v) const;
    Vector3D<T> operator+(const Vector3D<T>& v) const;
    const Vector3D<T>& add(const Vector3D<T>& v);
    const Vector3D<T>& operator+=(const Vector3D<T>& v);

  protected:
    T _data[3];
  };

	// Needed operator* that I don't know how to move to the cpp
	template <class T> Vector3D<T> operator* (T factor, const Vector3D<T>& v)
  {
    return v * factor;
  }

	// Needed operator* that I don't know how to move to the cpp
	template <class T> Vector3D<T> operator- (const Vector3D<T>& v)
  {
    return Vector3D<T>(-v._data[0], -v._data[1], -v._data[2]);
  }

	// Output operator
	// Format: "(a.aa, b.bbb, c.c)"
	template <class T>
  std::ostream& operator<< (std::ostream& out, const Vector3D<T>& v)
  {
    out  << v._data[0] << " " << v._data[1] << " " << v._data[2];

    return out;
  }

	// Input operator
	// Format: "a.aa b.bbb c.c"
	template <class T>
  std::istream& operator>> (std::istream& in, Vector3D<T>& v)
  {
		in >> v._data[0] >> v._data[1] >> v._data[2];

    return in;
  }

	typedef Vector3D<int> Vector3Di;
	typedef Vector3D<float> Vector3Df;
	typedef Vector3D<double> Vector3Dd;
	typedef Vector3D<short> Vector3Ds;
	typedef Vector3D<char> Vector3Dc;
};

#endif