#pragma once

#include <J3ML/LinearAlgebra.h>


namespace LinearAlgebra {
    class Vector4 {
    public:
        // Default Constructor
        Vector4();
        // Constructs a new Vector4 with x,y,z values from a Vector3
        Vector4(const Vector3& xyz, float w = 0);
        // Constructs a new Vector4 with the value (X, Y, Z, W)
        Vector4(float X, float Y, float Z, float W);
        Vector4(const Vector4& copy) = default;
        Vector4(Vector4&& move) = default;
        Vector4& operator=(const Vector4& rhs);


        float GetX() const;
        float GetY() const;
        float GetZ() const;
        float GetW() const;
#if MUTABLE
        void SetX(float newX) { x = newX;}
        void SetY(float newY) { y = newY;}
        void SetZ(float newZ) { z = newZ;}
        void SetW(float newW) { w = newW;}
#endif
        static const Vector4 Zero;
        static const Vector4 NaN;

        float operator[](std::size_t index) const;

        bool IsWithinMarginOfError(const Vector4& rhs, float margin=0.0001f) const;

        bool IsNormalized(float epsilonSq = 1e-5f) const;
        bool IsZero(float epsilonSq = 1e-6f) const;
        bool IsFinite() const;
        bool IsPerpendicular(const Vector4& other, float epsilonSq=1e-5f) const;

        bool operator==(const Vector4& rhs) const;
        bool operator!=(const Vector4& rhs) const;

        Vector4 Min(const Vector4& min) const;
        Vector4 Max(const Vector4& max) const;
        Vector4 Clamp(const Vector4& min, const Vector4& max) const;
        float Distance(const Vector4& to) const;
        float Length() const;
        float LengthSquared() const;
        float Magnitude() const;
        float Dot(const Vector4& rhs) const;
        Vector4 Project(const Vector4& rhs) const;
        // While it is feasable to compute a cross-product in four dimensions
        // the cross product only has the orthogonality property in 3 and 7 dimensions
        // You should consider instead looking at Gram-Schmidt Orthogonalization
        // to find orthonormal vectors.
        Vector4 Cross(const Vector4& rhs) const;
        Vector4 Normalize() const;
        Vector4 Lerp(const Vector4& goal, float alpha) const;

        float AngleBetween(const Vector4& rhs) const;

        // Adds two vectors
        Vector4 operator+(const Vector4& rhs) const;
        Vector4 Add(const Vector4& rhs) const;
        static Vector4 Add(const Vector4& lhs, const Vector4& rhs);

        // Subtracts two vectors
        Vector4 operator-(const Vector4& rhs) const;
        Vector4 Sub(const Vector4& rhs) const;
        static Vector4 Sub(const Vector4& lhs, const Vector4& rhs);

        // Multiplies this vector by a scalar value
        Vector4 operator*(float rhs) const;
        Vector4 Mul(float scalar) const;
        static Vector4 Mul(const Vector4& lhs, float rhs);

        // Divides this vector by a scalar
        Vector4 operator/(float rhs) const;
        Vector4 Div(float scalar) const;
        static Vector4 Div(const Vector4& rhs, float scalar);

        Vector4 operator+() const; // Unary + Operator
        Vector4 operator-() const; // Unary - Operator (Negation)
    public:
#if MUTABLE
        float x = 0;
        float y = 0;
        float z = 0;
        float w = 0;
#else
         float x = 0;
         float y = 0;
         float z = 0;
         float w = 0;
#endif
    };

}