#pragma once

#include <math.h>

#define SMALL_NUMBER		(1.e-8f)
#define KINDA_SMALL_NUMBER	(1.e-4f)
#define BIG_NUMBER			(3.4e+38f)

struct VectorCJM
{
public:
	float x, y, z;

public:


	VectorCJM() : x(0.0f), y(0.0f), z(0.0f) {}
	VectorCJM(float inX, float inY, float inZ) : x(inX), y(inY), z(inZ) {}

	static const VectorCJM ZeroVector;
	static const VectorCJM OneVector;
	static const VectorCJM UpVector;
	static const VectorCJM ForwardVector;
	static const VectorCJM RightVector;


	// 벡터 외적
	inline VectorCJM operator^(const VectorCJM& v) const
	{
		return VectorCJM(
			y * v.z - z * v.y,
			z * v.x - x * v.z,
			x * v.y - y * v.x
		);
	}
	inline static VectorCJM Cross(const VectorCJM& a, const VectorCJM& b)
	{
		return a ^ b;
	}

	// 벡터 내적
	inline float operator|(const VectorCJM& v) const
	{
		return x * v.x + y * v.y + z * v.z;
	}
	inline static float Dot(const VectorCJM& a, const VectorCJM& b)
	{
		return a | b;
	}


	// 사칙 연산
	inline VectorCJM operator+(const VectorCJM& v) const
	{
		return VectorCJM(x + v.x, y + v.y, z + v.z);
	}

	inline VectorCJM operator-(const VectorCJM& v) const
	{
		return VectorCJM(x - v.x, y - v.y, z - v.z);
	}

	inline VectorCJM operator*(float scale) const
	{
		return VectorCJM(x * scale, y * scale, z * scale);
	}
	inline VectorCJM operator*(const VectorCJM& v) const
	{
		return VectorCJM(x * v.x, y * v.y, z * v.z);
	}

	inline VectorCJM operator/(float scale) const
	{
		const float rScale = 1.0f / scale;
		return VectorCJM(x * rScale, y * rScale, z * rScale);
	}
	inline VectorCJM operator/(const VectorCJM& v) const
	{
		return VectorCJM(x / v.x, y / v.y, z / v.z);
	}


	inline bool operator==(const VectorCJM& v) const
	{
		return x == v.x && y == v.y && z == v.z;
	}
	inline bool operator!=(const VectorCJM& v) const
	{
		return x != v.x || y != v.y || z != v.z;
	}

	inline bool Equals(const VectorCJM& v, float tolerance = KINDA_SMALL_NUMBER) const
	{
		float absX = x - v.x;
		float absY = y - v.y;
		float absZ = z - v.z;

		if (absX < 0) absX *= -1.0f;
		if (absY < 0) absY *= -1.0f;
		if (absZ < 0) absZ *= -1.0f;
		return absX <= tolerance && absY <= tolerance && absZ <= tolerance;
	}

	inline VectorCJM operator-() const
	{
		return VectorCJM(x * -1.0f, y * -1.0f, z * 1.0f);
	}

	inline VectorCJM operator+=(const VectorCJM& v)
	{
		return VectorCJM(x + v.x, y + v.y, z + v.z);
	}

	inline VectorCJM operator-=(const VectorCJM& v)
	{
		return VectorCJM(x - v.x, y - v.y, z - v.z);
	}

	inline VectorCJM operator*=(float scale)
	{
		return VectorCJM(x * scale, y * scale, z * scale);
	}

	inline VectorCJM operator*=(const VectorCJM& v)
	{
		return VectorCJM(x * v.x, y * v.y, z * v.z);
	}

	inline VectorCJM operator/=(float scale)
	{
		float rScale = 1.0f / scale;
		return VectorCJM(x * rScale, y * rScale, z * rScale);
	}

	inline VectorCJM operator/=(const VectorCJM& v)
	{
		return VectorCJM(x / v.x, y / v.y, z / v.z);
	}


	inline bool IsZero() const
	{
		return x == 0.0f && y == 0.0f && z == 0.0f;
	}

	inline VectorCJM GetUnsafeNormal() const
	{
		const float scale = 1.0f / sqrtf(x * x + y * y + z * z);
		return VectorCJM(x * scale, y * scale, z * scale);
	}

	inline VectorCJM GetSafeNormal(float tolerance = SMALL_NUMBER) const
	{
		const float squareSum = x * x + y * y + z * z;

		if (squareSum == 1.0f)
			return *this;
		else if (squareSum < tolerance)
			return VectorCJM::ZeroVector;
		const float scale = 1.0f / sqrtf(squareSum);
		return VectorCJM(x*scale, y*scale, z*scale);
	}


	inline float Size() const
	{
		return sqrtf(x * x + y * y + z * z);
	}

	inline float SizeSquared() const
	{
		return x * x + y * y + z * z;
	}


	inline VectorCJM Reciprocal() const
	{
		VectorCJM recVector;
		if (x != 0.0f)
		{
			recVector.x = 1.0f / x;
		}
		else
		{
			recVector.x = BIG_NUMBER;
		}
		if (y != 0.0f)
		{
			recVector.y = 1.0f / y;
		}
		else
		{
			recVector.y = BIG_NUMBER;
		}
		if (z != 0.0f)
		{
			recVector.z = 1.0f / z;
		}
		else
		{
			recVector.z = BIG_NUMBER;
		}
	}

	inline float DistanceSquared(const VectorCJM& v)
	{
		float subX = v.x - x;
		float subY = v.y - y;
		float subZ = v.z - z;

		return subX * subX + subY * subY + subZ * subZ;
	}

	inline float Distance(const VectorCJM& v)
	{
		return sqrtf(DistanceSquared(v));
	}



};

const VectorCJM VectorCJM::ZeroVector(0.0f, 0.0f, 0.0f);
const VectorCJM VectorCJM::OneVector(0.0f, 0.0f, 0.0f);
const VectorCJM VectorCJM::UpVector(0.0f, 0.0f, 0.0f);
const VectorCJM VectorCJM::ForwardVector(0.0f, 0.0f, 0.0f);
const VectorCJM VectorCJM::RightVector(0.0f, 0.0f, 0.0f);