#pragma once
#include <iostream>
#include "JWmath.h"

#define default_point 0

struct  JWVector
{
public:
	// Vector's X copmponent.
	float X;

	// Vector's Y copmponent.
	float Y;

	// Vector's Z copmponent.
	float Z;

public:
	static const JWVector ZeroVector;
	static const JWVector OneVector;
	static const JWVector UpVector;
	static const JWVector DownVector;
	static const JWVector LeftVector;
	static const JWVector RightVector;
	static const JWVector ForwardVector;
	static const JWVector BackVector;

public:
	JWVector() { X = 0.0f; Y = 0.0f; Z = 0.0f; }
	JWVector(const float &InX, const float &InY) : X(InX), Y(InY), Z(default_point) {}
	JWVector(const float &inX, const float &inY, const float &inZ) : X(inX), Y(inY), Z(inZ) {}

	inline static float DotProduct(const JWVector &a, const JWVector &b);
	inline float operator|(const JWVector& b) const;
	inline static JWVector CrossProduct(const JWVector &a, const JWVector &b);
	inline JWVector operator^(const JWVector& b) const;

	inline JWVector operator+(const JWVector& b) const;
	inline JWVector operator+= (const JWVector& b);
	inline JWVector operator+(const float& bias) const;

	inline JWVector operator-(const JWVector& b) const;
	inline JWVector operator-=(const JWVector& b);
	inline JWVector operator-() const;
	inline JWVector operator-(const float& bias) const;

	inline JWVector operator*(const JWVector& b) const;
	inline JWVector operator*=(const JWVector& b);
	inline JWVector operator*(const float& Scale) const;
	inline JWVector operator*=(const float& Scale);

	inline JWVector operator/(const JWVector& b) const;
	inline JWVector operator/=(const JWVector& b);
	inline JWVector operator/(const float& Scale) const;
	inline JWVector operator/=(const float& Scale);

	inline static float Dist(const JWVector &a, const JWVector &b);
	inline static float Distance(const JWVector &a, const JWVector &b) { return Dist(a, b); }
	inline static float DistSquared(const JWVector&a, const JWVector&b);

	inline float SizeSquared() const;
	inline float Size() const;

	inline bool Equals(const JWVector& b) const;
	inline bool IsZero() const;
	inline bool operator==(const JWVector& b) const;
	inline bool operator!=(const JWVector& b) const;
	inline float& operator[](const int &index);
	inline float operator[](const int &index) const;

	inline bool Normalize(float Tolerance = SMALL_NUMBER);
	inline bool IsNormalized() const;
	inline JWVector GetUnsafeNormal() const;
	inline JWVector GetSafeNormal(float Tolerance = SMALL_NUMBER) const;
	inline JWVector Reciprocal() const;
	inline bool AllComponentEqual(float Tolerance = KINDA_SMALL_NUMBER) const;

};

const JWVector JWVector::ZeroVector(0.f, 0.f, 0.f);
const JWVector JWVector::OneVector(1.f, 1.f, 1.f);
const JWVector JWVector::UpVector(0.f, 0.f, 1.f);
const JWVector JWVector::DownVector(0.f, 0.f, -1.f);
const JWVector JWVector::LeftVector(0.f, -1.f, 0.f);
const JWVector JWVector::RightVector(0.f, 1.f, 0.f);
const JWVector JWVector::ForwardVector(1.f, 0.f, 0.f);
const JWVector JWVector::BackVector(-1.f, 0.f, 0.f);

inline float JWVector::operator|(const JWVector & b) const
{
	return
		(X * b.X) +
		(Y * b.Y) +
		(Z * b.Z);
}

inline JWVector JWVector::operator^(const JWVector & b) const
{
	return JWVector(
		(Y * b.Z) - (Z * b.Y),
		(Z * b.X) - (X * b.Z),
		(X * b.Y) - (Y * b.X)
	);
}

inline float JWVector::DotProduct(const JWVector & a, const JWVector & b)
{
	return a | b;
}

inline JWVector JWVector::CrossProduct(const JWVector & a, const JWVector & b)
{
	return a ^ b;
}

inline float JWVector::Dist(const JWVector & a, const JWVector & b)
{
	return Math::Sqrt(JWVector::DistSquared(a, b));
}

inline float JWVector::DistSquared(const JWVector & a, const JWVector & b)
{
	return Math::Square(b.X - a.X) + Math::Square(b.Y - a.Y) + Math::Square(b.Z - a.Z);
}

inline JWVector JWVector::operator+(const JWVector & b) const
{
	return JWVector(X + b.X, Y + b.Y, Z + b.Z);
}

inline JWVector JWVector::operator+(const float &bias) const
{
	return JWVector(X + bias, Y + bias, Z + bias);
}

inline JWVector JWVector::operator-(const JWVector & b) const
{
	return JWVector(X - b.X, Y - b.Y, Z - b.Z);
}

inline JWVector JWVector::operator-(const float &bias) const
{
	return JWVector(X - bias, Y - bias, Z - bias);
}

inline JWVector JWVector::operator-() const
{
	return JWVector(-X, -Y, -Z);
}

inline JWVector JWVector::operator*(const JWVector & V) const
{
	return JWVector(X * V.X, Y * V.Y, Z * V.Z);
}

inline JWVector JWVector::operator*(const float &Scale) const
{
	return JWVector(X * Scale, Y * Scale, Z * Scale);
}


inline JWVector JWVector::operator/(const JWVector & V) const
{
	return JWVector(X / V.X, Y / V.Y, Z / V.Z);
}

inline JWVector JWVector::operator/(const float & Scale) const
{
	const float RScale = 1.f / Scale;
	return JWVector(X * RScale, Y * RScale, Z * RScale);
}

inline bool JWVector::operator==(const JWVector & b) const
{
	return X == b.X && Y == b.Y && Z == b.Z;
}

inline bool JWVector::operator!=(const JWVector & b) const
{
	return X != b.X || Y != b.Y || Z != b.Z;
}

inline JWVector JWVector::operator+=(const JWVector & b)
{
	X += b.X; Y += b.Y; Z += b.Z;
	return *this;
}

inline JWVector JWVector::operator-=(const JWVector & b)
{
	X -= b.X; Y -= b.Y; Z -= b.Z;
	return *this;
}

inline JWVector JWVector::operator*=(const JWVector & b)
{
	X *= b.X; Y *= b.Y; Z *= b.Z;
	return *this;
}


inline JWVector JWVector::operator*=(const float & Scale)
{
	X *= Scale; Y *= Scale; Z *= Scale;
	return *this;
}

inline JWVector JWVector::operator/=(const JWVector& b)
{
	X /= b.X; Y /= b.Y; Z /= b.Z;
	return *this;
}

inline JWVector JWVector::operator/=(const float & Scale)
{
	const float RScale = 1.f / Scale;
	X *= RScale; Y *= RScale; Z *= RScale;
	return *this;
}

inline bool JWVector::Equals(const JWVector & b) const
{
	return X == b.X && Y == b.Y && Z == b.Z;
}

inline bool JWVector::AllComponentEqual(float Tolerance) const
{
	return Math::Abs(X - Y) <= Tolerance && Math::Abs(X - Z) <= Tolerance && Math::Abs(Y - Z) <= Tolerance;
}

inline bool JWVector::IsZero() const
{
	return X == 0.f && Y == 0.f && Z == 0.f;
}

inline float JWVector::Size() const
{
	return Math::Sqrt(SizeSquared());
}

inline float JWVector::SizeSquared() const
{
	return (X * X) + (Y * Y) + (Z * Z);
}

inline JWVector JWVector::GetUnsafeNormal() const
{
	const float Scale = Math::InvSqrt((X*X) + (Y*Y) + (Z*Z));
	return JWVector(X*Scale, Y*Scale, Z*Scale);
}

inline JWVector JWVector::GetSafeNormal(float Tolerance) const
{
	const float SquareSum = (X*X) + (Y*Y) + (Z*Z);

	if (SquareSum == 1.f)
	{
		return *this;
	}
	else if (SquareSum < Tolerance)
	{
		return JWVector::ZeroVector;
	}
	const float Scale = Math::InvSqrt(SquareSum);
	return JWVector(X*Scale, Y*Scale, Z*Scale);
}

inline JWVector JWVector::Reciprocal() const
{
	JWVector RecVector;

	if (X != 0.f)
		RecVector.X = 1.f / X;
	else
		RecVector.X = BIG_NUMBER;

	if (Y != 0.f)
		RecVector.Y = 1.f / Y;
	else
		RecVector.Y = BIG_NUMBER;

	if (Z != 0.f)
		RecVector.Z = 1.f / Z;
	else
		RecVector.Z = BIG_NUMBER;

	return RecVector;
}

bool JWVector::Normalize(float Tolerance)
{
	const float SquareSum = X * X + Y * Y + Z * Z;
	if (SquareSum > Tolerance)
	{
		const float Scale = Math::InvSqrt(SquareSum);
		X *= Scale; Y *= Scale; Z *= Scale;
		return true;
	}
	return false;
}

bool JWVector::IsNormalized() const
{
	return (Math::Abs(1.f - SizeSquared()) < THRESH_VECTOR_NORMALIZED);
}

float& JWVector::operator[](const int & Index)
{
	if(Index >= 0 && Index < 3)
		throw std::out_of_range("Array");

	else {
		if (Index == 0) return X;

		else if (Index == 1) return Y;

		else return Z;
	}
}

float JWVector::operator[](const int & Index)const
{
	if (Index < 0 || Index >= 3)
		throw std::out_of_range("Array");

	else
		if (Index == 0) return X;

		else if (Index == 1) return Y;

		else return Z;
}