/*
	Copyright (c) 2009 Christopher A. Taylor.  All rights reserved.

	Redistribution and use in source and binary forms, with or without
	modification, are permitted provided that the following conditions are met:

	* Redistributions of source code must retain the above copyright notice,
	  this list of conditions and the following disclaimer.
	* Redistributions in binary form must reproduce the above copyright notice,
	  this list of conditions and the following disclaimer in the documentation
	  and/or other materials provided with the distribution.
	* Neither the name of LibCat nor the names of its contributors may be used
	  to endorse or promote products derived from this software without
	  specific prior written permission.

	THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
	AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
	IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
	ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
	LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
	CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
	SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
	INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
	CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
	ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
	POSSIBILITY OF SUCH DAMAGE.
*/

#ifndef CAT_VECTOR_HPP
#define CAT_VECTOR_HPP

#include <cat/gfx/Scalar.hpp>

namespace cat {

#define FOR_EACH_DIMENSION(index) for (int index = 0; index < DIM; ++index)


// Generic vector class for linear algebra
template<int DIM, typename Scalar, typename Double> class Vector
{
protected:
	// Protected internal storage of vector components
	Scalar _elements[DIM];

public:
	// Short-hand for the current vector type
	typedef Vector<DIM, Scalar, Double> mytype;

	// Uninitialized vector is not cleared
	Vector() {}

	// Component-wise initializing constructors
	Vector(Scalar x, Scalar y)
	{
		_elements[0] = x;
		_elements[1] = y;
	}
	Vector(Scalar x, Scalar y, Scalar z)
	{
		_elements[0] = x;
		_elements[1] = y;
		_elements[2] = z;
	}
	Vector(Scalar x, Scalar y, Scalar z, Scalar w)
	{
		_elements[0] = x;
		_elements[1] = y;
		_elements[2] = z;
		_elements[3] = w;
	}

	// Make the vector a copy of a given vector
	mytype &copy(const mytype &u)
	{
		memcpy(_elements, u._elements, sizeof(_elements));

        return *this;
	}

	// Copy constructor
	Vector(const mytype &u)
	{
		copy(u);
	}

	// Assignment operator
	mytype &operator=(const mytype &u)
	{
        return copy(u);
	}

	// Magnitude calculation
	Double magnitude() const
	{
		Double element, sum = 0;

		FOR_EACH_DIMENSION(ii)
		{
			element = _elements[ii];
			sum += element * element;
		}

		return static_cast<Double>( sqrt(sum) );
	}

	// Fast normalization for 32-bit floating point elements in-place
	mytype &normalize_fast_f32()
	{
		f32 element = _elements[0];
		f32 sum = element * element;

		for (int ii = 1; ii < DIM; ++ii)
		{
			element = _elements[ii];
			sum += element * element;
		}

		// If sum is not close to 1, then perform normalization:
		if (sum > 1.005f || sum < 0.995f)
		{
			f32 inv = InvSqrt(sum);

			FOR_EACH_DIMENSION(ii) _elements[ii] *= inv;
		}

		return *this;
	}

	// Normalization in-place
	mytype &normalize()
	{
		Double m = magnitude();
		Double inv = static_cast<Double>( 1 ) / m;

		FOR_EACH_DIMENSION(ii) _elements[ii] *= inv;

		return *this;
	}

	// Zero elements
	void zero()
	{
		OBJCLR(_elements);
	}

	// Is zero?
	bool isZero()
	{
		FOR_EACH_DIMENSION(ii)
			if (_elements[ii] != static_cast<Scalar>( 0 ))
				return false;

		return true;
	}

	// For consistency with Matrix class, use the () operator instead of [] to index it
	inline Scalar &operator()(int ii) { return _elements[ii]; }
	inline Scalar &x() { return _elements[0]; }
	inline Scalar &y() { return _elements[1]; }
	inline Scalar &z() { return _elements[2]; }
	inline Scalar &w() { return _elements[3]; }

	// Const version for accessors
	inline const Scalar &operator()(int ii) const { return _elements[ii]; }
	inline const Scalar &x() const { return _elements[0]; }
	inline const Scalar &y() const { return _elements[1]; }
	inline const Scalar &z() const { return _elements[2]; }
	inline const Scalar &w() const { return _elements[3]; }

	// Negation
	mytype operator-() const
	{
		mytype x;

		FOR_EACH_DIMENSION(ii) x._elements[ii] = -_elements[ii];

		return x;
	}

	// Negation in-place
	mytype &negate()
	{
		FOR_EACH_DIMENSION(ii) _elements[ii] = -_elements[ii];

		return *this;
	}

	// Addition
	mytype operator+(const mytype &u) const
	{
		mytype x;

		FOR_EACH_DIMENSION(ii) x._elements[ii] = _elements[ii] + u._elements[ii];

		return x;
	}

	// Addition in-place
	mytype &operator+=(const mytype &u)
	{
		FOR_EACH_DIMENSION(ii) _elements[ii] += u._elements[ii];

		return *this;
	}

	// Add a scalar to each element in-place
	mytype &addToEachElement(Scalar u)
	{
		FOR_EACH_DIMENSION(ii) _elements[ii] += u;

		return *this;
	}

	// Subtraction
	mytype operator-(const mytype &u) const
	{
		mytype x;

		FOR_EACH_DIMENSION(ii) x._elements[ii] = _elements[ii] - u._elements[ii];

		return x;
	}

	// Subtraction in-place
	mytype &operator-=(const mytype &u)
	{
		FOR_EACH_DIMENSION(ii) _elements[ii] -= u._elements[ii];

		return *this;
	}

	// Subtract a scalar from each element in-place
	mytype &subtractFromEachElement(Scalar u)
	{
		FOR_EACH_DIMENSION(ii) _elements[ii] -= u;

		return *this;
	}

	// Scalar multiplication
	mytype operator*(Scalar u) const
	{
		mytype x;

		FOR_EACH_DIMENSION(ii) x._elements[ii] = u * _elements[ii];

		return x;
	}

	// Scalar multiplication in-place
	mytype &operator*=(Scalar u)
	{
		FOR_EACH_DIMENSION(ii) _elements[ii] *= u;

		return *this;
	}

	// Component-wise multiply in-place
	mytype &componentMultiply(const mytype &u)
	{
		FOR_EACH_DIMENSION(ii) _elements[ii] *= u._elements[ii];

		return *this;
	}

	// Scalar division
	mytype operator/(Scalar u) const
	{
		mytype x;

		Scalar inv_u = static_cast<Scalar>( 1 ) / static_cast<Scalar>( u );

		FOR_EACH_DIMENSION(ii) x._elements[ii] = _elements[ii] * inv_u;

		return x;
	}

	// Scalar division in-place
	mytype &operator/=(Scalar u)
	{
		Scalar inv_u = static_cast<Scalar>( 1 ) / static_cast<Scalar>( u );

		FOR_EACH_DIMENSION(ii) _elements[ii] *= inv_u;

		return *this;
	}

	// Component-wise divide in-place
	mytype &componentDivide(const mytype &u)
	{
		FOR_EACH_DIMENSION(ii) _elements[ii] /= u._elements[ii];

		return *this;
	}

	// Dot product
	Double dotProduct(const mytype &u) const
	{
		Double sum = 0;

		FOR_EACH_DIMENSION(ii)
			sum += static_cast<Double>( _elements[ii] )
				* static_cast<Double>( u._elements[ii] );

		return sum;
	}

public:
	// Only for 2-element vectors:

	// Generate a 2D rotation vector in-place
	void generateRotation2D(f32 angle)
	{
		x() = cos(angle);
		y() = sin(angle);
	}

	// Add rotation vector in-place
	mytype &addRotation2D(const mytype &r)
	{
		Double ax = x(), ay = y();
		Double rx = r.x(), ry = r.y();

		x() = static_cast<Scalar>( ax*rx - ay*ry ); // cos(a+r) = cos(a)*cos(r) - sin(a)*sin(r)
		y() = static_cast<Scalar>( ay*rx + ax*ry ); // sin(a+r) = sin(a)*cos(r) + cos(a)*sin(r)

		return *this;
	}

	// Subtract rotation vector in-place
	mytype &subtractRotation2D(const mytype &r)
	{
		Double ax = x(), ay = y();
		Double rx = r.x(), ry = r.y();

		x() = static_cast<Scalar>( ax*rx + ay*ry ); // cos(a-r) = cos(a)*cos(r) + sin(a)*sin(r)
		y() = static_cast<Scalar>( ay*rx - ax*ry ); // sin(a-r) = sin(a)*cos(r) - cos(a)*sin(r)

		return *this;
	}

	// Cross product: Result is a scalar
	f32 crossProduct2D(const mytype &u)
	{
		return x() * u.y() - y() * u.x();
	}

public:
	// Only for 3-element vectors:

	// Cross product: Result is a 3D vector
	mytype crossProduct3D(const mytype &u)
	{
		mytype result;

		result.x() = y() * u.z() - z() * u.y();
		result.y() = z() * u.x() - x() * u.z();
		result.z() = x() * u.y() - y() * u.x();

		return result;
	}
};


// Short-hand for common usages:

typedef Vector<2, u32, u32> Vector2u;
typedef Vector<3, u32, u32> Vector3u;
typedef Vector<4, u32, u32> Vector4u;

typedef Vector<2, s32, s32> Vector2s;
typedef Vector<3, s32, s32> Vector3s;
typedef Vector<4, s32, s32> Vector4s;

typedef Vector<2, f32, f64> Vector2f;
typedef Vector<3, f32, f64> Vector3f;
typedef Vector<4, f32, f64> Vector4f;

typedef Vector<2, f64, f64> Vector2d;
typedef Vector<3, f64, f64> Vector3d;
typedef Vector<4, f64, f64> Vector4d;


#undef FOR_EACH_DIMENSION

} // namespace cat

#endif // CAT_VECTOR_HPP