#ifndef VECTOR_H

#define VECTOR_H

#include <cassert></cassert>

#include "common.h"

template<typename lt="" st,="" typename=""></typename>

class VectorBase2T {

public:

	typedef VectorBase2T<st, lt=""> SelfTypeArg;</st,>

	typedef ST SelfType;

	typedef LT LowerType;

	typedef SelfType Vector2;

	typedef LowerType Coord;

	enum { Count = 2 };

	union {

		struct { Coord coords[Count]; };

		struct { Coord x, y; };

	};

	inline explicit VectorBase2T(const Coord &x = Coord(), const Coord &y = Coord()):

		x(x), y(y) { }

	inline SelfType perp() const

		{ return SelfType(-y, x); }

	inline SelfType yx() const

		{ return SelfType(y, x); }

};

template<typename lt="" st,="" typename=""></typename>

class VectorBase3T {

public:

	typedef VectorBase3T<st, lt=""> SelfTypeArg;</st,>

	typedef ST SelfType;

	typedef LT LowerType;

	typedef SelfType Vector3;

	typedef LowerType Vector2;

	typedef typename LowerType::Coord Coord;

	enum { Count = 3 };

	union {

		struct { Coord coords[Count]; };

		struct { Coord x, y, z; };

	};

	inline explicit VectorBase3T(const Coord &x = Coord(), const Coord &y = Coord(), const Coord &z = Coord()):

		x(x), y(y), z(z) { }

	inline VectorBase3T(const Vector2 &v, const Coord &z):

		x(v.x), y(v.y), z(z) { }

	inline SelfType cross(const SelfTypeArg &other) const

		{ return SelfType(y*other.z - z*other.y, z*other.x - x*other.z, x*other.y - y*other.x); }

	inline Vector2& vec2()

		{ return *(Vector2*)this; };

	inline const Vector2& vec2() const

		{ return *(const Vector2*)this; };

	inline SelfType xzy() const

		{ return SelfType(x, z, y); }

	inline SelfType zxy() const

		{ return SelfType(z, x, y); }

	inline SelfType zyx() const

		{ return SelfType(z, y, x); }

	inline SelfType yxz() const

		{ return SelfType(y, x, z); }

	inline SelfType yzx() const

		{ return SelfType(y, z, x); }

};

template<typename lt="" st,="" typename=""></typename>

class VectorBase4T {

public:

	typedef VectorBase4T<st, lt=""> SelfTypeArg;</st,>

	typedef ST SelfType;

	typedef LT LowerType;

	typedef SelfType Vector4;

	typedef LowerType Vector3;

	typedef typename LowerType::Vector2 Vector2;

	typedef typename LowerType::Coord Coord;

	enum { Count = 4 };

	union {

		struct { Coord coords[Count]; };

		struct { Coord x, y, z, w; };

	};

	inline explicit VectorBase4T(const Coord &x = Coord(), const Coord &y = Coord(), const Coord &z = Coord(), const Coord &w = Coord()):

		x(x), y(y), z(z), w(w) { }

	inline VectorBase4T(const Vector2 &v, const Coord &z, const Coord &w = Coord()):

		x(v.x), y(v.y), z(z), w(w) { }

	inline VectorBase4T(const Vector3 &v, const Coord &w):

		x(v.x), y(v.y), z(v.z), w(w) { }

	inline Vector3& vec3()

		{ return *(Vector3*)this; };

	inline const Vector3& vec3() const

		{ return *(const Vector3*)this; };

		inline Vector2& vec2()

		{ return *(Vector2*)this; };

	inline const Vector2& vec2() const

		{ return *(const Vector2*)this; };

	inline SelfType cross(const SelfTypeArg &other) const

		{ return SelfType(y*other.z - z*other.y, z*other.x - x*other.z, x*other.y - y*other.x, w); }

};

template<typename t=""></typename>

class VectorT: public T {

public:

	typedef VectorT<t> SelfTypeArg;</t>

	typedef T ParentType;

	using ParentType::Count;

	using typename ParentType::Coord;

	using typename ParentType::SelfType;

	using ParentType::coords;

	using ParentType::ParentType; // contructors

	inline VectorT() { }

	inline explicit VectorT(const Coord *c) {

		assert(c);

		for(int i = 0; i < Count; ++i) coords[i] = c[i];

	}

	template<typename tt=""></typename>

	inline explicit VectorT(const VectorT<tt> &v) {</tt>

		const int cnt = (int)TT::Count < (int)Count ? (int)TT::Count : (int)Count;

		for(int i = 0; i < cnt; ++i) coords[i] = Coord(v.coords[i]);

		for(int i = cnt; i < Count; ++i) coords[i] = Coord();

	}

	Coord& operator[] (int i)

		{ assert(i >= 0 && i < Count); return coords[i]; }

	const Coord& operator[] (int i) const

		{ assert(i >= 0 && i < Count); return coords[i]; }

	inline bool operator< (const SelfTypeArg &other) const {

		for(int i = 0; i < Count; ++i)

			if (coords[i] < other.coords[i]) return true;

			else if (other.coords[i] < coords[i]) return false;

		return false;

	}

	inline bool operator== (const SelfTypeArg &other) const {

		for(int i = 0; i < Count; ++i)

			if (coords[i] != other.coords[i]) return false;

		return true;

	}

	inline bool operator!= (const SelfTypeArg &other) const

		{ return !(*(const SelfType*)this == other); }

	inline SelfType& operator+= (const SelfTypeArg &other) {

		for(int i = 0; i < Count; ++i) coords[i] += other.coords[i];

		return *(SelfType*)this;

	}

	inline SelfType& operator-= (const SelfTypeArg &other) {

		for(int i = 0; i < Count; ++i) coords[i] -= other.coords[i];

		return *(SelfType*)this;

	}

	inline SelfType& operator*= (const Coord &c) {

		for(int i = 0; i < Count; ++i) coords[i] *= c;

		return *(SelfType*)this;

	}

	inline SelfType operator- () const {

		SelfType v;

		for(int i = 0; i < Count; ++i) v.coords[i] = -coords[i];

		return v;

	}

	inline Coord operator* (const SelfTypeArg &other) const {

		Coord r = Coord();

		for(int i = 0; i < Count; ++i) r += coords[i]*other.coords[i];

		return r;

	}

	inline SelfType operator+ (const SelfTypeArg &other) const

		{ return SelfType(*this) += other; }

	inline SelfType operator- (const SelfTypeArg &other) const

		{ return SelfType(*this) -= other; }

	inline SelfType operator* (const Coord &c) const

		{ return SelfType(*this) *= c; }

	inline Coord square() const

		{ return *this * *this; }

	inline static SelfType& cast(Coord *c)

		{ return *(SelfType*)c; }

	inline static const SelfType& cast(const Coord *c)

		{ return *(const SelfType*)c; }

};

template<typename t=""></typename>

class VectorFT: public VectorT<t> {</t>

public:

	typedef VectorFT<t> SelfTypeArg;</t>

	typedef VectorT<t> ParentType;</t>

	using ParentType::Count;

	using typename ParentType::Coord;

	using typename ParentType::SelfType;

	using ParentType::coords;

	using ParentType::ParentType; // contructors

	inline SelfType& operator/= (const Coord &c)

		{ return *this *= Coord(1)/c; }

	inline SelfType operator/ (const Coord &c)

		{ return SelfType(*this) /= c; }

	inline Coord length() const

		{ return Coord(sqrt(ParentType::square())); }

	inline bool operator< (const SelfTypeArg &other) const {

		for(int i = 0; i < Count; ++i)

			if (coords[i] < other.coords[i] - real_precision) return true;

			else if (other.coords[i] < coords[i] - real_precision) return false;

		return false;

	}

	inline bool operator== (const SelfTypeArg &other) const {

		for(int i = 0; i < Count; ++i)

			if ( coords[i] < other.coords[i] - real_precision

			  || other.coords[i] < coords[i] - real_precision ) return false;

		return true;

	}

	inline bool operator!= (const SelfTypeArg &other) const

		{ return !(*(const SelfType*)this == other); }

};

template<typename t=""></typename>

class Vectors {

public:

	typedef T Type;

	class Vector2: public VectorT< VectorBase2T<vector2, type=""> > {</vector2,>

	public:

		typedef VectorT< VectorBase2T<vector2, type=""> > ParentType;</vector2,>

		using ParentType::ParentType; // constructors

	};

	class Vector3: public VectorT< VectorBase3T<vector3, vector2=""> > {</vector3,>

	public:

		typedef VectorT< VectorBase3T<vector3, vector2=""> > ParentType;</vector3,>

		using ParentType::ParentType; // constructors

	};

	class Vector4: public VectorT< VectorBase4T<vector4, vector3=""> > {</vector4,>

	public:

		typedef VectorT< VectorBase4T<vector4, vector3=""> > ParentType;</vector4,>

		using ParentType::ParentType; // constructors

	};

};

template<typename t=""></typename>

class VectorsFloat {

public:

	typedef T Type;

	class Vector2: public VectorFT< VectorBase2T<vector2, type=""> > {</vector2,>

	public:

		typedef VectorFT< VectorBase2T<vector2, type=""> > ParentType;</vector2,>

		using ParentType::ParentType; // constructors

	};

	class Vector3: public VectorFT< VectorBase3T<vector3, vector2=""> > {</vector3,>

	public:

		typedef VectorFT< VectorBase3T<vector3, vector2=""> > ParentType;</vector3,>

		using ParentType::ParentType; // constructors

	};

	class Vector4: public VectorFT< VectorBase4T<vector4, vector3=""> > {</vector4,>

	public:

		typedef VectorFT< VectorBase4T<vector4, vector3=""> > ParentType;</vector4,>

		using ParentType::ParentType; // constructors

	};

};

typedef VectorsFloat<real>::Vector2 Vector2;</real>

typedef VectorsFloat<real>::Vector3 Vector3;</real>

typedef VectorsFloat<real>::Vector4 Vector4;</real>

typedef VectorsFloat<int>::Vector2 IntVector2;</int>

typedef VectorsFloat<int>::Vector3 IntVector3;</int>

typedef VectorsFloat<int>::Vector4 IntVector4;</int>

typedef VectorsFloat<longint>::Vector2 LongIntVector2;</longint>

typedef VectorsFloat<longint>::Vector3 LongIntVector3;</longint>

typedef VectorsFloat<longint>::Vector4 LongIntVector4;</longint>

typedef VectorsFloat<uint>::Vector2 UIntVector2;</uint>

typedef VectorsFloat<uint>::Vector3 UIntVector3;</uint>

typedef VectorsFloat<uint>::Vector4 UIntVector4;</uint>

typedef VectorsFloat<ulongint>::Vector2 ULongIntVector2;</ulongint>

typedef VectorsFloat<ulongint>::Vector3 ULongIntVector3;</ulongint>

typedef VectorsFloat<ulongint>::Vector4 ULongIntVector4;</ulongint>

#endif